perm filename TEX.PAS[TEX,ALS]1 blob
sn#606700 filedate 1981-08-18 generic text, type C, neo UTF8
COMMENT ā VALID 00025 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00003 00002 (* TEX STANFORD CS AUGUST 1981.
C00020 00003 PROCEDURE initstrings
C00032 00004 FUNCTION getnode(size: integer):
C00049 00005 PROCEDURE dumplist(p,q: integer)
C00065 00006 PROCEDURE hpackext(p: integer)
C00080 00007 PROCEDURE macrodef(gdef: integer)
C00095 00008 PROCEDURE opendigit(d: integer)
C00110 00009 PROCEDURE scandelim(VAR delimiters: bytes4)
C00126 00010 PROCEDURE tracedump(p: integer)
C00142 00011 PROCEDURE definefont
C00159 00012 PROCEDURE initsftable(periodspacing,queryspacing,exclspacing,
C00177 00013 PROCEDURE justification(initwidth: real linechange: integer
C00201 00014 PROCEDURE finishparagraph(penlt: boolean)
C00220 00015 PROCEDURE donescripts
C00253 00016 PROCEDURE boxfield(p:integer
C00273 00017 PROCEDURE movew(amount:real)
C00288 00018 PROCEDURE right(amount:real)
C00308 00019 PROCEDURE shipout(p:integer)
C00326 00020 PROCEDURE pageeject
C00341 00021 PROCEDURE initstacks
C00356 00022 PROCEDURE setdelimiters
C00371 00023 PROCEDURE appendusualglue
C00385 00024 PROCEDURE allocateeqno
C00405 00025 PROCEDURE inittables
C00408 ENDMK
Cā;
(* TEX STANFORD CS AUGUST 1981.
TEX WAS DESIGNED BY DONALD E. KNUTH,
WHO INITIALLY IMPLEMENTED IT IN SAIL.
THIS PASCAL VERSION OF TEX
IS DUE TO IGNACIO A. ZABALA. *)
(*$R80,S8000,X11,T-,G+,D-,O-,Y+*)
PROGRAM tex;
LABEL 100,101;
CONST nop= 128;
bop= 129;
eop= 130;
pst= 131;
dvipush= 132;
dvipop= 133;
vertrule= 134;
horzrule= 135;
horzchar= 136;
dvifont= 137;
w4= 138;
w3= 139;
w2= 140;
w0= 141;
x4= 142;
x3= 143;
x2= 144;
x0= 145;
y4= 146;
y3= 147;
y2= 148;
y0= 149;
z4= 150;
z3= 151;
z2= 152;
z0= 153;
fontnum= 154;
TYPE asciicode= 0..127;
asciistring= ARRAY[0..63] OF
asciicode;
oneoftwo= 1..2;
oneoffour= 1..4;
oneofsix= 1..6;
halves2= PACKED RECORD
lhword: 0..65535;
CASE oneoftwo OF
1:(rhword: 0..65535);
2:(byte2: 0..255;
byte3: 0..255)
END;
bytes4= PACKED RECORD
byte0: 0..255;
byte1: 0..255;
CASE oneoftwo OF
1:(rhword: 0..65535);
2:(byte2: 0..255;
byte3: 0..255)
END;
memoryword= PACKED RECORD CASE
oneoffour OF
1:(pts: real);
2:(int: integer);
3:(twohalves: halves2);
4:(fourbytes: bytes4)
END;
memarray= ARRAY[0..49152] OF
memoryword;
hasharray= ARRAY[23..1009] OF
halves2;
hheadarray= ARRAY[0..88] OF
integer;
eqtbarray= ARRAY[0..1428] OF
memoryword;
buffir= ARRAY[1..200] OF asciicode;
inputstate= RECORD
buffer: buffir;
bufptr: integer;
curbuf: integer;
state: integer;
loc: integer;
recovery: halves2;
lvl: integer END;
warnstate=(ok, defof, useof, preambleof);
pagememarray= ARRAY[0..7] OF real;
delimarray= ARRAY[0..127] OF bytes4;
fntinfoarray= ARRAY[0..63,0..127] OF bytes4;
fmemarray= ARRAY[0..6399] OF memoryword;
fbasearray= ARRAY[0..63] OF integer;
fpfiarray= ARRAY[0..63,1..5] OF bytes4;
exception=PACKED ARRAY[1..12] OF 0..31;
hyphenbits=SET OF 1..16;
pckdhyphbits=PACKED SET OF 1..16;
packedalphas=PACKED SET OF 0..26;
pckdconspair=PACKED RECORD
hchar:0..7;
weak:0..7;
alphaset:packedalphas
END;
opcode=0..15;
truthx=0..255;
hoperand=0..255;
suffixtp=PACKED RECORD
code: opcode;
CASE oneoftwo OF
1:(truex:truthx;
falsex:truthx;
oprand:hoperand);
2:(alphaset:packedalphas)
END;
prefixtp=suffixtp;
tblreadouttype= RECORD CASE oneofsix
OF
1:(excptblvariant:exception);
2:(excphyphvariant:pckdhyphbits);
3:(suffixvariant:suffixtp);
4:(prefixvariant:prefixtp);
5:(btablevariant:pckdconspair);
6:(readoutvariant:ARRAY[1..3]
OF integer)
END;
excparray= ARRAY[0..372] OF
exception;
excphyarray= ARRAY[1..372] OF
pckdhyphbits;
suffixarray= ARRAY[0..115] OF
suffixtp;
prefixarray= ARRAY[0..108] OF
prefixtp;
barray= ARRAY[2..31] OF pckdconspair;
sizesarray= ARRAY[0..11] OF
integer;
VAR mem: memarray;
rover: integer;(* CHECKINGMEM:
INTEGER;
DYNUSED: INTEGER;
VARUSED: INTEGER;
WASFREE: PACKED ARRAY[0..49151]
OF BOOLEAN;
FREE: PACKED ARRAY[0..49151]
OF BOOLEAN;*)
curcmd: integer;
curchar: integer;
curfont: integer;
hash: hasharray;
hhead: hheadarray;
eqtb: eqtbarray;
escapechar: asciicode;
curlev: integer;
savestack:ARRAY[0..302] OF memoryword;
saveptr: integer;
hashentry: integer;
nonewcontrolseq:boolean;
instack: ARRAY[0..80] OF inputstate;
inptr: integer;
curinput: inputstate;
brchar: asciicode;
eoff: boolean;
parstack:ARRAY[0..25] OF integer;
parptr: integer;
pstack: ARRAY[0..25] OF integer;
pagewarning: warnstate;
warnindex: integer;
tokstring: PACKED ARRAY[0..1,1..700]
OF asciicode;
toksptr: ARRAY[0..1] OF integer;
nooutputyet: boolean;
pausingonerrors: boolean;
errcnt: integer;
notnonstop: boolean;
deletsallowed: boolean;
q:integer;
toktyp, tokval: integer;
hashpar, hashsend: integer;
curtyp, curval: integer;
nbrlength: integer;
nbrsign: asciicode;
savedbox: ARRAY[48..58] OF integer;
savedpage: integer;
modestack: ARRAY[0..39] OF integer;
mode: integer;
headstack: ARRAY[0..39] OF integer;
head: integer;
curndstack: ARRAY[0..39] OF integer;
curnode: integer;
auxstack: ARRAY[0..39] OF memoryword;
aux: memoryword;
nestptr: integer;
pagesize: real;
pageheight: real;
pagedepth: real;
pageinsdepth: ARRAY[0..1] OF real;
pagemaxdepth: real;
pagetopbl: real;
pagestretch, pageshrink: real;
pagetail: integer;
waitingtail: integer;
emptypage: integer;
finaleject: boolean;
insabsent: ARRAY[0..1] OF boolean;
curbreak: integer;
curbadness: real;
kount: ARRAY[48..57] OF integer;
savedknt: ARRAY[48..57] OF integer;
outputdormant: boolean;
topmark,botmark,firstmark: integer;
outputroutine: integer;
pagemem: pagememarray;
fontsize: ARRAY[0..7] OF integer;
scrstyle: ARRAY[0..7] OF integer;
undstyle: ARRAY[0..7] OF integer;
numstyle: ARRAY[0..7] OF integer;
denomstyle: ARRAY[0..7] OF integer;
eqnobox: integer;
dpenalty: integer;
leqno: boolean;
abovedspwidth: real;
delimtable: delimarray;
fontinfo: fntinfoarray;
fmem: fmemarray;
fmemptr: integer;
wdbase: fbasearray;
htbase: fbasearray;
dpbase: fbasearray;
icbase: fbasearray;
lgbase: fbasearray;
krbase: fbasearray;
extbase: fbasearray;
parbase: fbasearray;
fcksum: fbasearray;
fontused: fbasearray;
fpfb: fbasearray;
fmag: fbasearray;
fpfi: fpfiarray;
suptable: ARRAY[0..7] OF integer;
str,shr: real;
sftable: ARRAY[0..127] OF real;
exceptable: excparray;
excephyph: excphyarray;
suffix: suffixarray;
prefix: prefixarray;
btable: barray;
readoutvariable:tblreadouttype;
hangwidth: real;
hangbegin: integer;
hangfirst: integer;
inhangbegin,inhangfirst: integer;
inhangwidth: real;
lines: integer;
lastwidth: real;
parshape: integer;
lowestbadness: ARRAY[0..3] OF
real;
leastbadness: real;
bestplace,bestline: ARRAY[0..3]
OF integer;
autobreaking: boolean;
curwd,curst,cursh: real;(* DIAGNOSE:
ARRAY[1..700] OF ASCIICODE;
DIAGPTR: INTEGER;*)
fount:integer;
curquad: real;
curxspace: real;
spacetable: ARRAY[0..6,0..6]
OF integer;
algnlststack: ARRAY[0..3] OF
integer;
alignlist: integer;
algnrcrdstack: ARRAY[0..3] OF
integer;
alignrecord: integer;
algnststack: ARRAY[0..3] OF integer;
alignstate: integer;
alignptr: integer;
dvibytecnt: integer;
maxpagewidth,maxpageheight:real;
thispageptr,lastpageptr:integer;
x,y:real;
wamt,xamt,yamt,zamt:integer;
lastfont:integer;
fourbytesize: integer;
action: integer;
curbox: integer;
curnoad: integer;
chrcode: memoryword;
curitem: integer;
curins: integer;
deadcycles: integer;
len: real;
dimmode: integer;
romval: ARRAY[1..7] OF integer;
romlet: ARRAY[1..7] OF asciicode;
firstonpage: boolean;
sendout: ARRAY[48..57] OF integer;
initializing: integer;
INITPROCEDURE;
BEGIN
savedbox[48]:=0;
savedbox[49]:=0;
savedbox[50]:=0;
savedbox[51]:=0;
savedbox[52]:=0;
savedbox[53]:=0;
savedbox[54]:=0;
savedbox[55]:=0;
savedbox[56]:=0;
savedbox[57]:=0;
savedbox[58]:=0;
kount[48]:=0;
kount[49]:=0;
kount[50]:=0;
kount[51]:=0;
kount[52]:=0;
kount[53]:=0;
kount[54]:=0;
kount[55]:=0;
kount[56]:=0;
kount[57]:=0;
topmark:=0;
botmark:=0;
firstmark:=0;
outputroutine:=0;
fontsize[0]:= 0;
fontsize[1]:= 0;
fontsize[2]:= 4;
fontsize[3]:= 8;
fontsize[4]:= 0;
fontsize[5]:= 0;
fontsize[6]:= 4;
fontsize[7]:= 8;
scrstyle[0]:= 2;
scrstyle[1]:= 2;
scrstyle[2]:= 3;
scrstyle[3]:= 3;
scrstyle[4]:= 6;
scrstyle[5]:= 6;
scrstyle[6]:= 7;
scrstyle[7]:= 7;
undstyle[0]:= 4;
undstyle[1]:= 5;
undstyle[2]:= 6;
undstyle[3]:= 7;
undstyle[4]:= 4;
undstyle[5]:= 5;
undstyle[6]:= 6;
undstyle[7]:= 7;
numstyle[0]:= 1;
numstyle[1]:= 2;
numstyle[2]:= 3;
numstyle[3]:= 3;
numstyle[4]:= 5;
numstyle[5]:= 6;
numstyle[6]:= 7;
numstyle[7]:= 7;
denomstyle[0]:= 5;
denomstyle[1]:= 6;
denomstyle[2]:= 7;
denomstyle[3]:= 7;
denomstyle[4]:= 5;
denomstyle[5]:= 6;
denomstyle[6]:= 7;
denomstyle[7]:= 7;
suptable[0]:= 12;
suptable[1]:= 13;
suptable[2]:= 13;
suptable[3]:= 13;
suptable[4]:= 14;
suptable[5]:= 14;
suptable[6]:= 14;
suptable[7]:= 14;
spacetable[0,0]:= 7;
spacetable[0,1]:= 8;
spacetable[0,2]:=17;
spacetable[0,3]:=9;
spacetable[0,4]:= 7;
spacetable[0,5]:= 7;
spacetable[0,6]:= 7;
spacetable[1,0]:=8;
spacetable[1,1]:= 8;
spacetable[1,2]:= 0;
spacetable[1,3]:= 9;
spacetable[1,4]:= 7;
spacetable[1,5]:= 7;
spacetable[1,6]:= 7;
spacetable[2,0]:= 17;
spacetable[2,1]:= 17;
spacetable[2,2]:= 0;
spacetable[2,3]:= 0;
spacetable[2,4]:= 17;
spacetable[2,5]:= 0;
spacetable[2,6]:= 0;
spacetable[3,0]:= 9;
spacetable[3,1]:= 9;
spacetable[3,2]:= 0;
spacetable[3,3]:= 7;
spacetable[3,4]:= 9;
spacetable[3,5]:= 7;
spacetable[3,6]:= 7;
spacetable[4,0]:= 7;
spacetable[4,1]:= 7;
spacetable[4,2]:= 0;
spacetable[4,3]:= 7;
spacetable[4,4]:= 7;
spacetable[4,5]:= 7;
spacetable[4,6]:= 7;
spacetable[5,0]:= 7;
spacetable[5,1]:= 8;
spacetable[5,2]:= 17;
spacetable[5,3]:= 9;
spacetable[5,4]:= 7;
spacetable[5,5]:= 7;
spacetable[5,6]:= 7;
spacetable[6,0]:= 15;
spacetable[6,1]:= 15;
spacetable[6,2]:= 0;
spacetable[6,3]:= 9;
spacetable[6,4]:= 15;
spacetable[6,5]:= 15;
spacetable[6,6]:= 15;
romval[1]:=1000;
romval[2]:=500;
romval[3]:=100;
romval[4]:=50;
romval[5]:=10;
romval[6]:=5;
romval[7]:=1;
romlet[1]:=109;
romlet[2]:=100;
romlet[3]:=99;
romlet[4]:=108;
romlet[5]:=120;
romlet[6]:=118;
romlet[7]:=105;
END;
PROCEDURE initstrings;
EXTERN;
PROCEDURE producestring(c: integer;
VAR namestring: asciistring);
EXTERN;
FUNCTION appndstring(d,s:integer): integer;
EXTERN;
FUNCTION appndreal(d:integer; s:real): integer;
EXTERN;
PROCEDURE initsysdep(VAR fourbytesize: integer);
EXTERN;
PROCEDURE release(fyl: integer);
EXTERN;
FUNCTION inchter: asciicode;
EXTERN;
PROCEDURE inlnter(VAR buffer: buffir;
VAR bufptr: integer;
VAR brchar: asciicode);
EXTERN;
PROCEDURE outcherr(c: asciicode);
EXTERN;
PROCEDURE outlnerr;
EXTERN;
PROCEDURE sendch(stream: integer; c: asciicode);
EXTERN;
PROCEDURE sendln(stream: integer);
EXTERN;
FUNCTION sendstarted(stream: integer):
boolean;
EXTERN;
PROCEDURE close(stream: integer);
EXTERN;
PROCEDURE print(mes: integer);
EXTERN;
PROCEDURE println(mes: integer);
EXTERN;
PROCEDURE printint(n: integer);
EXTERN;
PROCEDURE printreal(x: real);
EXTERN;
PROCEDURE printoctal(n: integer);
EXTERN;
PROCEDURE printfilename(fyl: integer);
EXTERN;
PROCEDURE forcebufferout;
EXTERN;
PROCEDURE inln(fyl: integer;
VAR buffer: buffir;
VAR bufptr: integer;
VAR brchar: asciicode;
VAR eoff: boolean);
EXTERN;
FUNCTION getfirstline(fyl: integer;
VAR buffer: buffir;
VAR bufptr: integer;
VAR brchar: asciicode;
VAR eoff: boolean;
VAR page: integer): boolean;
EXTERN;
PROCEDURE traceline(VAR buffer: buffir; VAR bufptr: integer);
EXTERN;
PROCEDURE declareofil(fyl: integer);
EXTERN;
FUNCTION initfilename(fnum: integer): integer;
EXTERN;
FUNCTION appendtoname(cmmd, ch: integer): integer;
EXTERN;
FUNCTION readfontinfo(fyl: integer;
VAR fontinfo: fntinfoarray;
VAR fmem: fmemarray;
VAR wdbase,htbase,dpbase,icbase,lgbase,krbase,extbase,parbase: fbasearray;
VAR fcksum,fpfb,fmag: fbasearray;
VAR fpfi: fpfiarray;
VAR fmemptr: integer;
psize: real;
atclause: boolean): integer;
EXTERN;
PROCEDURE dvi(byte: integer);
EXTERN;
PROCEDURE intout(i: integer);
EXTERN;
PROCEDURE closeout(dvibytecnt, lastpageptr, magnification: integer;
maxpageheight, maxpagewidth: real;
VAR parbase, fcksum, fmag, fontused: fbasearray);
EXTERN;
FUNCTION gettablesizes(VAR sizestable: sizesarray): boolean;
EXTERN;
PROCEDURE initsecondmem(VAR mem: memarray);
EXTERN;
PROCEDURE initeqtb(VAR eqtb: eqtbarray;
VAR hash: hasharray;
VAR hhead: hheadarray;
VAR hashpar: integer;
VAR hashsend: integer);
EXTERN;
PROCEDURE inithyphentb(VAR readoutvariable: tblreadouttype;
VAR exceptable: excparray;
VAR excephyph: excphyarray;
VAR suffix: suffixarray;
VAR prefix: prefixarray;
VAR btable: barray);
EXTERN;
PROCEDURE initpagetb(VAR pagemem: pagememarray);
EXTERN;
PROCEDURE initdelimtb(VAR delimtable: delimarray);
EXTERN;
PROCEDURE initfmem(VAR fmem: fmemarray;
VAR wdbase,htbase,dpbase,icbase,lgbase,krbase,extbase,parbase: fbasearray;
VAR fontinfo: fntinfoarray;
VAR fcksum,fpfb, fmag: fbasearray;
VAR fpfi: fpfiarray;
VAR fmemptr: integer);
EXTERN;
PROCEDURE dumpcontext;
FORWARD;
PROCEDURE backinput;
FORWARD;
PROCEDURE pushinput;
FORWARD;
PROCEDURE popinput;
FORWARD;
PROCEDURE aligndelim;
FORWARD;
PROCEDURE getnext;
FORWARD;
PROCEDURE getncnext;
FORWARD;
PROCEDURE gettok;
FORWARD;
PROCEDURE getnctok;
FORWARD;
FUNCTION scantoks: integer;
FORWARD;
PROCEDURE dumptokens(p: integer);
FORWARD;
PROCEDURE macrocall;
FORWARD;
FUNCTION scanstring(particle: integer): boolean;
FORWARD;
FUNCTION scanlength: real;
FORWARD;
PROCEDURE quit;
BEGIN
GOTO 100;
END;
PROCEDURE error;
LABEL 0;
VAR c: asciicode;
j: integer;
BEGIN
dumpcontext;
IF pausingonerrors THEN BEGIN
WHILE true DO BEGIN
println(94);
c:=inchter;
outcherr(c);
IF c=13 THEN GOTO 0;
BEGIN
IF(c>=65) AND(c<=90) THEN
c:=c+(97-65)
END;
IF(c=99) THEN GOTO 0;
IF(c=10) OR(c=115) THEN
BEGIN pausingonerrors:=false;
GOTO 0
END;
IF(c=12) OR(c=115) THEN
BEGIN notnonstop:=false;
pausingonerrors:=false;
GOTO 0
END;
IF c=105 THEN BEGIN
pushinput;
println(42);
WITH curinput DO
BEGIN state:= 1;
loc:=-1;
inlnter(buffer,bufptr,brchar);
curbuf:=1;
bufptr:=bufptr-1
END;
WITH curinput DO FOR j:=curbuf TO bufptr-1 DO outcherr(buffer[j]);
outlnerr;
GOTO 0
END;
IF c=120 THEN
BEGIN println(371);
c:=inchter;
IF(c=120) OR(c=88) THEN quit;
END;
IF((c>=48) AND(c<=57))
AND deletsallowed THEN
BEGIN
c:=c-48;
WHILE c>0 DO
BEGIN
getnext;
c:= c-1
END;
dumpcontext
END
ELSE BEGIN
println(372);
IF deletsallowed THEN println(373);
println(374);
END
END;
0:
END
ELSE BEGIN
errcnt:=errcnt+1;
IF errcnt>=100 THEN
BEGIN println(375);
quit;
END;
END;
END;
PROCEDURE overflow(s: integer; n: integer);
BEGIN
pausingonerrors:=false;
println(376);
print(s);
printint(n);
print(377);
error;
quit
END;
PROCEDURE confusion;
BEGIN
pausingonerrors:=false;
println(378);
error;
quit;
END;
PROCEDURE mustquit;
BEGIN
pausingonerrors:=false;
println(379);
error;
quit;
END;
FUNCTION maximum(x,y: real): real;
BEGIN
IF x>y THEN maximum:=x
ELSE maximum:=y;
END;
FUNCTION minimum(m,n: integer):
integer;
BEGIN
IF m>n THEN minimum:=n
ELSE minimum:=m;
END;
PROCEDURE initmem;
VAR i,f: integer;
BEGIN
(* DYNUSED:=0; VARUSED:=0;
FOR I:=(30+(64*4)) TO 24999 DO WASFREE[I]:=TRUE;
FOR I:=25012 TO 49151 DO WASFREE[I]:=TRUE;*);
mem[0].twohalves.rhword:=50000;
mem[0+2].pts:=10000000000.0;
mem[0+1].pts:=0.0;
mem[0+3].pts:=0.0;
mem[4].twohalves.rhword:=50000;
mem[4+2].pts:=100000.0;
mem[4+1].pts:=0.0;
mem[4+3].pts:=0.0;
mem[8].twohalves.rhword:=50000;
mem[8+2].pts:=-mem[4+2].pts;
mem[8+1].pts:=0.0;
mem[8+3].pts:=0.0;
mem[12].twohalves.rhword:=50000;
mem[12+2].pts:=100000.0;
mem[12+3].pts:=100000.0;
mem[12+1].pts:=0.0;
mem[16].twohalves.rhword:=50000;
mem[16+1].pts:=0.0;
mem[16+2].pts:=0.0;
mem[16+3].pts:=0.0;
mem[20].twohalves.lhword:=0;
mem[25].twohalves.lhword:=0;
f:=30;
FOR i:=0 TO 63 DO
BEGIN mem[f].twohalves.rhword:=0;
mem[f+1].pts:=0.0;
mem[f+2].pts:=0.0;
mem[f+3].pts:=0.0;
f:=f+4
END;
mem[(30+(64*4))+1].twohalves.lhword:=(30+(64*4));
mem[(30+(64*4))].twohalves.lhword:=(30+(64*4));
mem[(30+(64*4))].twohalves.rhword:=65535;
mem[(30+(64*4))+1].twohalves.rhword:=25000-(30+(64*4));
rover:=(30+(64*4));
mem[25000].twohalves.rhword:=0;
mem[25000].twohalves.lhword:=0;
mem[25001].twohalves.lhword:=0;
mem[25002].twohalves.lhword:=0;
mem[25003].twohalves.lhword:=0;
mem[25004].twohalves.lhword:=0;
mem[25005].twohalves.lhword:=0;
mem[25006].twohalves.lhword:=0;
mem[25007].twohalves.lhword:=0;
mem[25008].twohalves.lhword:=0;
mem[25009].twohalves.lhword:=0;
FOR i:=25012 TO 49151 DO mem[i+1].twohalves.lhword:=i;
mem[25012].twohalves.lhword:=0
END;
FUNCTION getnode(size: integer):
integer;
LABEL 0, 1;
VAR p:integer;
q:integer;
s: integer;
BEGIN
p:= rover;
REPEAT
BEGIN
q:=p+mem[p+1].twohalves.rhword;
WHILE(mem[q].twohalves.rhword=65535) DO
BEGIN
IF(q=rover) THEN
BEGIN rover:=mem[q].twohalves.lhword;
IF(q=rover) THEN GOTO 0
END;
mem[mem[q].twohalves.lhword+1].twohalves.lhword:=
mem[q+1].twohalves.lhword;
mem[mem[q+1].twohalves.lhword].twohalves.lhword:=
mem[q].twohalves.lhword;
mem[q].twohalves.rhword:=0;;
q:=q+mem[q+1].twohalves.rhword
END;
s:=q-p;
IF s>=size+2 THEN BEGIN q:=q-size;
mem[p+1].twohalves.rhword:=q-p;
rover:=p;
GOTO 1
END;
IF s=size THEN BEGIN
IF(p=rover) THEN
BEGIN rover:=mem[p].twohalves.lhword;
IF(p=rover) THEN GOTO 0
END;
mem[mem[p].twohalves.lhword+1].twohalves.lhword:=
mem[p+1].twohalves.lhword;
mem[mem[p+1].twohalves.lhword].twohalves.lhword:=
mem[p].twohalves.lhword;
mem[p].twohalves.rhword:=0;;
rover:=mem[p].twohalves.lhword;
q:=p;
GOTO 1
END;
mem[p+1].twohalves.rhword:=s;
p:=mem[p].twohalves.lhword
END;
UNTIL p=rover;
0:
overflow(132,25000);
1:
WITH mem[q].twohalves
DO BEGIN rhword:=0;
lhword:=0 END;
mem[q+1].twohalves.lhword:=0;
getnode:=q;(* VARUSED:=VARUSED+SIZE;*)
END;
PROCEDURE freenode(p,size: integer);
VAR q:integer;
BEGIN
q:=mem[rover+1].twohalves.lhword;
mem[p+1].twohalves.lhword:=q;
mem[p].twohalves.lhword:=rover;
mem[p+1].twohalves.rhword:=size;
mem[p].twohalves.rhword:=65535;
mem[rover+1].twohalves.lhword:=p;
mem[q].twohalves.lhword:=p;(* VARUSED:=VARUSED-SIZE;*)
END;
FUNCTION getavail: integer;
VAR p: integer;
BEGIN
p:=mem[49152].twohalves.lhword;
IF p<>0 THEN mem[49152].twohalves
.lhword:=mem[mem[49152].twohalves.lhword].twohalves.lhword
ELSE overflow(133,49152);
mem[p].twohalves.lhword:=0;
getavail:=p;(* DYNUSED:=DYNUSED+1;*)
END;
PROCEDURE freeavail(p: integer);
BEGIN
IF p<25012 THEN freenode(p,2)
ELSE BEGIN mem[p].twohalves.lhword:=mem[49152].twohalves.lhword;
mem[49152].twohalves.lhword:=p;(* DYNUSED:=DYNUSED-1;*)
END
END;
PROCEDURE dslist(p: integer);
VAR q:integer;
BEGIN
WHILE p<>0 DO
BEGIN q:=mem[p].twohalves.lhword;
freeavail(p);
p:=q
END
END;
PROCEDURE delrclink(p: integer);
BEGIN
IF mem[p].twohalves.rhword>0 THEN
mem[p].twohalves.rhword:=mem[p].twohalves.rhword-1
ELSE dslist(p)
END;
PROCEDURE delgluelink(p: integer);
BEGIN
IF mem[p].twohalves.rhword>0 THEN
mem[p].twohalves.rhword:=mem[p].twohalves.rhword-1
ELSE freenode(p,4)
END;
(* PROCEDURE CHECKMEM(PRINTLOCS:
BOOLEAN);
LABEL 0, 1;
VAR P,I: INTEGER;
BEGIN
FOR I:=0 TO 49151 DO FREE[I]:=FALSE;
P:=MEM[49152].TWOHALVES.LHWORD;
WHILE P<>0 DO
BEGIN
IF(MEM[P].TWOHALVES.LHWORD>=49152) OR FREE[P] OR
((MEM[P].TWOHALVES.LHWORD<>0) AND
(MEM[P].TWOHALVES.LHWORD<=25000)) THEN
BEGIN PRINTLN(134);
PRINTINT(P);
GOTO 0;
END;
FREE[P]:=TRUE;
P:=MEM[P].TWOHALVES.LHWORD;
END;
0:
P:=ROVER;
REPEAT
IF(P>=25000) OR(P<=0) OR
(NOT (MEM[P].TWOHALVES.RHWORD=65535)) OR
(P+MEM[P+1].TWOHALVES.RHWORD>25000)
OR(MEM[P+1].TWOHALVES.RHWORD<2)
OR(MEM[MEM[P].TWOHALVES.LHWORD+1].TWOHALVES.LHWORD<>P) THEN
BEGIN
PRINTLN(135);
PRINTINT(P);
PRINTLN(136);
PRINTINT(MEM[P].TWOHALVES.BYTE2);
PRINTLN(137);
PRINTINT(MEM[P+1].TWOHALVES.RHWORD);
PRINTLN(138);
PRINTINT(MEM[P].TWOHALVES.LHWORD);
PRINTLN(139);
PRINTINT(MEM[MEM[P].TWOHALVES
.LHWORD+1].TWOHALVES.LHWORD);
GOTO 1;
END;
FOR I:=P TO(P+MEM[P+1].TWOHALVES
.RHWORD-1) DO
BEGIN IF FREE[I] THEN
BEGIN
PRINTLN(140);
PRINTINT(I);
GOTO 1;
END;
FREE[I]:=TRUE
END;
P:=MEM[P].TWOHALVES.LHWORD
UNTIL P=ROVER;
1:
IF PRINTLOCS THEN
BEGIN I:=0;
WHILE I<25000 DO
BEGIN IF(MEM[I].TWOHALVES.RHWORD=65535) THEN
BEGIN
PRINTLN(141);
PRINTINT(I);
PRINT(142);
PRINTINT(MEM[I+1].TWOHALVES.RHWORD);
END;
I:=I+1;
WHILE(I<25000) AND(NOT FREE[I])
DO I:=I+1
END;
PRINTLN(143);
END;
FOR I:=0 TO 49151 DO
BEGIN IF WASFREE[I] AND(NOT FREE[I])
AND PRINTLOCS THEN
PRINTINT(I);
WASFREE[I]:=FREE[I]
END
END;*)
(* PROCEDURE SEARCHMEM(P: INTEGER);
VAR I: INTEGER;
BEGIN
FOR I:=0 TO 49151 DO
BEGIN
IF(I<25000) AND(MEM[I+1].TWOHALVES
.LHWORD=P) THEN
BEGIN
PRINTLN(144);
PRINTINT(I)
END;
IF MEM[I].TWOHALVES.LHWORD=P THEN
BEGIN
PRINTLN(145);
PRINTINT(I)
END
END;
FOR I:=0 TO 797+127 DO
IF EQTB[I].FOURBYTES.RHWORD=P
THEN
BEGIN
PRINT(146);
PRINTINT(I);
PRINT(93)
END
END;*)
PROCEDURE initsave;
BEGIN
curlev:=1;
saveptr:=0
END;
PROCEDURE eqdestroy(eq: memoryword);
BEGIN
WITH eq.fourbytes
DO
CASE byte0
OF
16: delrclink(rhword);
18: delgluelink(rhword);
OTHERS:
END;
END;
PROCEDURE eqdefine(inx,comd,linc:integer);
BEGIN
IF(eqtb[inx].fourbytes.byte1=curlev)
THEN eqdestroy(eqtb[inx])
ELSE IF curlev>1 THEN BEGIN
IF(saveptr>=299)
THEN overflow(147,300);
savestack[saveptr]:=eqtb[inx];
saveptr:=saveptr+1;
WITH savestack[saveptr].fourbytes DO
BEGIN byte0:=1;
rhword:=inx END;
saveptr:=saveptr+1;
END;
WITH eqtb[inx].fourbytes DO
BEGIN byte1:=curlev;
byte0:=comd;
rhword:=linc
END;
END;
PROCEDURE chcodedef(inx: integer; valu: memoryword);
BEGIN
IF curlev>1 THEN BEGIN
IF(saveptr>=299)
THEN overflow(147,300);
savestack[saveptr]:=eqtb[inx];
saveptr:=saveptr+1;
WITH savestack[saveptr].fourbytes DO
BEGIN byte0:=1;
rhword:=inx END;
saveptr:=saveptr+1;
END;
eqtb[inx]:=valu
END;
FUNCTION unsave: integer;
LABEL 0;
BEGIN
curlev:=curlev-1;
IF curlev<>0 THEN BEGIN
WHILE true DO BEGIN
saveptr:=saveptr-1;
WITH savestack[saveptr].fourbytes DO
CASE byte0
OF
0: BEGIN unsave:=rhword;
GOTO 0 END;
1: IF(rhword<1137) AND(eqtb[rhword].fourbytes.byte1=1) THEN
BEGIN saveptr:=saveptr-1;
eqdestroy(savestack[saveptr])
END
ELSE BEGIN
IF rhword<1137 THEN eqdestroy(eqtb[rhword]);
saveptr:=saveptr-1;
eqtb[rhword]:= savestack[saveptr]
END;
2: IF eqtb[rhword].fourbytes.byte1<>1 THEN
BEGIN
eqdestroy(eqtb[rhword]);
eqtb[rhword].fourbytes.byte0:=83;
END;
OTHERS:
confusion
END;
END;
0:
END
ELSE BEGIN
curlev:=1;
unsave:=1
END
END;
PROCEDURE newsavelevel(endcode:integer);
BEGIN
IF saveptr>=300 THEN overflow(148,300);
WITH savestack[saveptr].fourbytes
DO BEGIN byte0:=0;
rhword:=endcode END;
saveptr:=saveptr+1;
curlev:=curlev+1;
IF curlev>=255 THEN overflow(149,255)
END;
PROCEDURE idlookup(single: boolean; conseq, h: integer);
LABEL 0, 50;
VAR q,r: integer;
BEGIN
IF single THEN
BEGIN
hashentry:= 1009+conseq;
IF eqtb[hashentry].fourbytes.byte0<>83 THEN GOTO 50
END
ELSE BEGIN
hashentry:= hhead[h];
WHILE(hashentry<1009)
DO
BEGIN q:=hash[hashentry].rhword;
r:=conseq;
WHILE(mem[q].twohalves.byte2=mem[r].twohalves.byte2) AND
(mem[q].twohalves.byte3=mem[r].twohalves.byte3) DO
BEGIN q:=mem[q].twohalves.lhword;
r:=mem[r].twohalves.lhword;
IF(q=0) AND(r=0) THEN BEGIN
dslist(conseq);
GOTO 50
END;
IF(q=0) OR(r=0) THEN GOTO
0
END;
0:
hashentry:=hash[hashentry].lhword
END
END;
IF nonewcontrolseq THEN
BEGIN
hashentry:=1137;
IF NOT single THEN dslist(conseq);
END
ELSE BEGIN
IF NOT single THEN
BEGIN
hashentry:=hash[1009].lhword;
IF hashentry<0 THEN overflow(150,1009);
hash[1009].lhword:=hash[hashentry].lhword;
hash[hashentry].rhword:=conseq;
hash[hashentry].lhword:=hhead[h];
hhead[h]:=hashentry END;
eqtb[hashentry].fourbytes.byte1:=curlev;
IF curlev>1 THEN BEGIN
IF saveptr>=300 THEN overflow(151,300);
WITH savestack[saveptr].fourbytes DO
BEGIN byte0:=2;
rhword:=hashentry END;
saveptr:=saveptr+1
END
END;
50:
END;
PROCEDURE controlseq;
VAR c: integer;
p,q,r: integer;
h: integer;
inoddposition: boolean;
BEGIN
WITH curinput DO
BEGIN
c:=buffer[curbuf];
curbuf:=curbuf+1;
IF(eqtb[c+1137].int=11) AND
(eqtb[buffer[curbuf]+1137].int=11)
THEN
BEGIN p:=getavail;
q:=p;
inoddposition:=true;
mem[q].twohalves.byte2:=c;
h:=256*c;
REPEAT
c:=buffer[curbuf];
BEGIN
IF(c>=65) AND(c<=90) THEN
c:=c+(97-65)
END;
curbuf:=curbuf+1;
inoddposition:=NOT inoddposition;
IF inoddposition THEN
BEGIN
r:=getavail;
mem[q].twohalves.lhword:=r;
q:=r;
h:=h+256*c;
mem[q].twohalves.byte2:=c;
END
ELSE BEGIN h:=h+c;
mem[q].twohalves.byte3:=c
END
UNTIL NOT(eqtb[buffer[curbuf]+1137].int=11);
IF inoddposition THEN
mem[q].twohalves.byte3:=0;
h:= abs(h) MOD 89;
idlookup(false,p,h);
END
ELSE idlookup(true,c,0)
END
END;
FUNCTION idname(h:integer): integer;
BEGIN
IF(h>=1136) OR(h<23) THEN idname:=152
ELSE IF h>=1009 THEN idname:=h-1009
ELSE IF hash[h].rhword<1 THEN idname:=153
ELSE idname:=-hash[h].rhword
END;
PROCEDURE showidname(h: integer);
LABEL 0;
VAR id: integer;
p,ch: integer;
BEGIN
id:=idname(h);
IF id>=0 THEN print(id)
ELSE
BEGIN p:=-id;
REPEAT print(mem[p].twohalves.byte2);
ch:=mem[p].twohalves.byte3;
IF ch=0 THEN GOTO 0
ELSE print(ch);
p:=mem[p].twohalves.lhword
UNTIL p=0;
0:
END
END;
PROCEDURE dumplist(p,q: integer);
LABEL 0;
VAR j: integer;
parnum: asciicode;
firstsublist: boolean;
comd,valu: integer;
conseqid: integer;
np: integer;
PROCEDURE appendstring(str: integer);
VAR particle: asciistring;
partinx: integer;
partch: asciicode;
BEGIN
producestring(str,particle);
partinx:=0;
partch:=particle[0];
WHILE partch<>0 DO
BEGIN toksptr[j]:=toksptr[j]+1;
tokstring[j,toksptr[j]]:=partch;
partinx:=partinx+1;
partch:=particle[partinx]
END
END;
BEGIN
toksptr[0]:=0;
toksptr[1]:=0;
j:=0;
parnum:=48;
WHILE p<>0
DO
BEGIN
IF p=q
THEN j:=1;
IF(p<0) OR(p>=49152)
THEN
BEGIN
BEGIN toksptr[j]:=toksptr[j]+1;
tokstring[j,toksptr[j]]:= escapechar
END;
appendstring(154);
GOTO 0
END;
WITH mem[p].twohalves
DO BEGIN comd:=byte2;
valu:=byte3
END;
CASE comd OF
0: BEGIN BEGIN toksptr[j]:=toksptr[j]+1;
tokstring[j,toksptr[j]]:= escapechar
END;
BEGIN
p:=mem[p].twohalves.lhword;
conseqid:=idname(mem[p].twohalves.rhword);
IF conseqid>=0 THEN BEGIN appendstring(conseqid);
IF eqtb[conseqid+1137].int=11
THEN BEGIN toksptr[j]:=toksptr[j]+1;
tokstring[j,toksptr[j]]:= 32
END
END
ELSE BEGIN np:=-conseqid;
REPEAT
BEGIN toksptr[j]:=toksptr[j]+1;
tokstring[j,toksptr[j]]:=
mem[np].twohalves.byte2
END;
IF mem[np].twohalves.byte3<>0 THEN
BEGIN toksptr[j]:=toksptr[j]+1;
tokstring[j,toksptr[j]]:=
mem[np].twohalves.byte3
END;
np:=mem[np].twohalves.lhword
UNTIL np=0;
BEGIN toksptr[j]:=toksptr[j]+1;
tokstring[j,toksptr[j]]:= 32
END
END
END;
END;
14: IF valu=0 THEN BEGIN BEGIN
toksptr[j]:=toksptr[j]+1;
tokstring[j,toksptr[j]]:= 35
END;
parnum:=parnum+1;
BEGIN toksptr[j]:=toksptr[j]+1;
tokstring[j,toksptr[j]]:= parnum
END
END
ELSE appendstring(156);
9: BEGIN BEGIN toksptr[j]:=toksptr[j]+1;
tokstring[j,toksptr[j]]:= 35
END;
BEGIN toksptr[j]:=toksptr[j]+1;
tokstring[j,toksptr[j]]:= valu+49
END
END;
6: BEGIN BEGIN toksptr[j]:=toksptr[j]+1;
tokstring[j,toksptr[j]]:= 35
END;
BEGIN toksptr[j]:=toksptr[j]+1;
tokstring[j,toksptr[j]]:= 35
END
END;
10: BEGIN toksptr[j]:=toksptr[j]+1;
tokstring[j,toksptr[j]]:= 32
END;
15: BEGIN BEGIN toksptr[j]:=toksptr[j]+1;
tokstring[j,toksptr[j]]:= escapechar
END;
appendstring(157) END;
1,2,3,4,7,8,11,12: BEGIN toksptr[j]:=toksptr[j]+1;
tokstring[j,toksptr[j]]:= valu
END;
OTHERS:
BEGIN
BEGIN toksptr[j]:=toksptr[j]+1;
tokstring[j,toksptr[j]]:= escapechar
END;
appendstring(158) END
END;
IF(toksptr[j]>eqtb[1418].int-50) THEN
BEGIN
BEGIN toksptr[j]:=toksptr[j]+1;
tokstring[j,toksptr[j]]:= escapechar
END;
appendstring(155);
GOTO 0
END;
p:=mem[p].twohalves.lhword
END;
0:
END;
PROCEDURE dumptokens;
VAR j: integer;
BEGIN
dumplist(p,0);
FOR j:=1 TO toksptr[0] DO print(tokstring[0,j]);
END;
PROCEDURE pushinput;
BEGIN
IF inptr>=80 THEN overflow(159,80);
instack[inptr]:=curinput;
inptr:=inptr+1;
END;
PROCEDURE popinput;
BEGIN
inptr:=inptr-1;
curinput:=instack[inptr];
WITH curinput DO brchar:=buffer[bufptr];
IF(brchar<>13) AND(brchar<>12)
THEN brchar:=0
END;
PROCEDURE inslist(p: integer);
BEGIN
pushinput;
WITH curinput DO
BEGIN
state:=0;
loc:=p;
recovery.lhword:=p;
recovery.rhword:=3 END;
END;
PROCEDURE insrclist(l: integer);
BEGIN
pushinput;
WITH curinput DO
BEGIN
state:=0;
loc:=mem[l].twohalves.lhword;
recovery.lhword:=l;
recovery.rhword:=4;
curbuf:=parptr END;
mem[l].twohalves.rhword:=
mem[l].twohalves.rhword+1
END;
PROCEDURE initin;
BEGIN
inptr:=0;
escapechar:=0;
WITH curinput DO
BEGIN
state:=29;
bufptr:=1;
curbuf:=bufptr+1;
loc:=-1;
lvl:=0;
END;
pagewarning:=ok;
nonewcontrolseq:=false;
pausingonerrors:=true;
deletsallowed:=true;
notnonstop:=true
END;
PROCEDURE poptokenlist;
BEGIN
WITH curinput DO
CASE recovery.rhword
OF
0, 2:;
1: alignstate:= 0;
3: dslist(recovery.lhword);
OTHERS:
BEGIN
delrclink(recovery.lhword);
WHILE parptr>curbuf DO
BEGIN parptr:=parptr-1;
dslist(parstack[parptr]) END
END
END;
popinput END;
PROCEDURE dumpcontext;
LABEL 0,
1;
VAR ptr: integer;
t: integer;
firstpos: integer;
first, last: integer;
j: integer;
BEGIN
instack[inptr]:=curinput;
ptr:=inptr;
WHILE true DO BEGIN
WHILE instack[ptr].state=0 DO
WITH instack[ptr] DO
BEGIN
CASE recovery.rhword
OF
0: BEGIN
println(160);
firstpos:=12;
t:=recovery.lhword
END;
1: BEGIN
println(161);
firstpos:=9;
t:=recovery.lhword
END;
2: BEGIN
println(162);
firstpos:=9;
t:=recovery.lhword
END;
3: IF loc<>0
THEN
BEGIN println(163);
firstpos:=20;
t:=recovery.lhword
END
ELSE GOTO 1;
4: BEGIN
println(-1);
firstpos:=1;
t:=mem[recovery.lhword].twohalves.lhword
END;
OTHERS:
confusion
END;
dumplist(t,loc);
IF toksptr[0]>32 THEN
BEGIN print(164);
firstpos:=firstpos+3;
first:=4+toksptr[0]-32
END
ELSE first:=1;
FOR j:=first TO toksptr[0] DO
print(tokstring[0,j]);
println(-1);
FOR j:=first TO firstpos-1+toksptr[0]
DO print(32);
IF toksptr[1]>32 THEN last:=29
ELSE last:=toksptr[1];
FOR j:=1 TO last DO print(tokstring[1,j]);
IF last<>toksptr[1] THEN print(165);
1:;
ptr:=ptr-1
END;
WITH instack[ptr] DO
BEGIN
IF loc<>-1
THEN BEGIN
println(167);
printint(recovery.rhword);
print(168);
printint(recovery.lhword);
println(-1);
firstpos:=1
END
ELSE BEGIN println(166);
firstpos:=5
END;
FOR j:=1 TO curbuf-1 DO print(buffer[j]);
println(-1);
FOR j:=1 TO firstpos+curbuf-1
DO print(32);
FOR j:=curbuf TO bufptr-1 DO print(buffer[j]);
END;
IF(instack[ptr].loc<>-1) OR
(ptr=0)
THEN GOTO 0;
ptr:=ptr-1
END;
0:
END;
PROCEDURE whatsitappend(p: integer);
VAR q: integer;
BEGIN
IF abs(mode)<>167 THEN q:=p
ELSE BEGIN q:=getnode(2);
mem[q].twohalves.byte2:=14;
mem[p].twohalves.lhword:=0;
mem[q+1].fourbytes.rhword:=p
END;
BEGIN
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END;
END;
PROCEDURE sendit(p: integer);
VAR stream, tlist: integer;
token: integer;
j: integer;
BEGIN
IF mem[p+1].twohalves.lhword<>0 THEN
BEGIN
stream:=sendout[mem[p+1].twohalves
.rhword];
tlist:=mem[p+1].twohalves.lhword;
token:=getavail;
mem[token].twohalves.byte2:=2;
mem[token].twohalves.byte3:=126;
inslist(token);
insrclist(tlist);
delrclink(tlist);
token:=getavail;
mem[token].twohalves.byte2:=1;
mem[token].twohalves.byte3:=123;
inslist(token);
mem[p+1].twohalves.lhword:=0;
curcmd:=21;
hashentry:=hashsend;
tlist:=scantoks;
poptokenlist;
dumplist(mem[tlist].twohalves
.lhword,0);
dslist(tlist);
IF stream=-1 THEN BEGIN IF
firstonpage THEN println(-1);
FOR j:=1 TO toksptr[0] DO print(tokstring[0,j]);
firstonpage:=false;
END
ELSE BEGIN FOR j:=1 TO toksptr[0]
DO sendch(stream,tokstring[0,j]);
sendln(stream)
END
END
END;
PROCEDURE initext;
VAR d: integer;
BEGIN
FOR d:=48 TO 57 DO sendout[d]:=-1;
END;
PROCEDURE extop;
BEGIN
println(380);
error;
END;
PROCEDURE dumpext(p: integer);
VAR j: integer;
BEGIN
CASE mem[p].twohalves.byte3
OF
0:IF mem[p+1].twohalves.lhword<>0 THEN
BEGIN dumplist(mem[mem[p+1].twohalves
.lhword].twohalves.lhword,0);
print(381);
print(mem[p+1].twohalves.rhword);
print(123);
IF toksptr[0]>30 THEN BEGIN FOR
j:=1 TO 30 DO print(tokstring[0,j]);
print(382)
END
ELSE BEGIN FOR j:=1 TO toksptr[0]
DO print(tokstring[0,j]);
print(126)
END
END
ELSE print(383);
OTHERS:
print(384)
END;
END;
PROCEDURE destroyext(p: integer);
BEGIN
CASE mem[p].twohalves.byte3
OF
0: BEGIN IF mem[p+1].twohalves
.lhword<>0 THEN delrclink(mem[p+1].twohalves
.lhword);
freenode(p,2);
END;
OTHERS:
BEGIN println(385);
error;
quit
END
END
END;
FUNCTION copyext(p: integer):
integer;
VAR q, r: integer;
BEGIN
CASE mem[p].twohalves.byte3
OF
0: BEGIN r:=getnode(2);
WITH mem[r].twohalves
DO BEGIN byte2:=3;
byte3:=0 END;
mem[r+1]:=mem[p+1];
q:=mem[r+1].twohalves.lhword;
IF q<>0 THEN mem[q].twohalves
.rhword:=mem[q].twohalves.rhword+1
END;
OTHERS:
BEGIN println(386);
error;
quit
END
END;
copyext:=r
END;
PROCEDURE hpackext(p: integer);
BEGIN
END;
PROCEDURE vpackext(p: integer);
BEGIN
END;
PROCEDURE pageext(p: integer);
BEGIN
END;
PROCEDURE justext(p: integer);
BEGIN
END;
PROCEDURE houtext(p: integer;
VAR x,y: real);
BEGIN
CASE mem[p].twohalves.byte3
OF
0: sendit(p);
OTHERS:
END
END;
PROCEDURE voutext(p: integer;
VAR x,y: real);
BEGIN
CASE mem[p].twohalves.byte3
OF
0: sendit(p);
OTHERS:
END
END;
PROCEDURE finishext;
VAR d: integer;
BEGIN
FOR d:=0 TO 9 DO IF sendstarted(d)
THEN close(d);
END;
PROCEDURE pageendcheck(l: integer);
BEGIN
deletsallowed:=false;
IF curlev<>l THEN BEGIN
println(169);
IF curlev>l THEN
BEGIN print(43);
printint(curlev-l);
END
ELSE BEGIN print(45);
printint(l-curlev);
END;
print(170);
error;
END;
IF pagewarning=useof THEN BEGIN
mem[q].twohalves.byte2:=toktyp;
IF toktyp=0 THEN
BEGIN mem[q].twohalves.lhword:=getavail;
q:=mem[q].twohalves.lhword;
mem[q].twohalves.rhword:=tokval
END
ELSE mem[q].twohalves.byte3:=tokval;
println(171);
println(-1);
dumptokens(mem[25003].twohalves
.lhword) END;
IF pagewarning<>ok THEN BEGIN
println(172);
CASE pagewarning OF
useof: print(173);
defof: print(174);
OTHERS:
confusion
END;
print(escapechar);
showidname(warnindex);
print(46);
error;
END;
deletsallowed:=true
END;
PROCEDURE getnext;
LABEL 0, 1, 2;
VAR lsave: integer;
j: integer;
BEGIN
0:
WITH curinput DO
IF state<>0 THEN 2:
IF curbuf<=bufptr THEN BEGIN
curchar:=buffer[curbuf];
curcmd:=eqtb[curchar+1137].int;
curbuf:=curbuf+1;
CASE state+curcmd OF
10, 24,
25, 38, 39:GOTO 2;
1, 15,
29:BEGIN controlseq;
WITH eqtb[hashentry].fourbytes
DO
BEGIN curcmd:=byte0;
IF(curcmd=58) OR(curcmd=54)
OR(curcmd=55) THEN
BEGIN curfont:=byte2;
curchar:=byte3
END
ELSE curchar:=rhword
END;
state:=15
END;
14,
28, 42:BEGIN
curbuf:=curbuf-1;
controlseq;
WITH eqtb[hashentry].fourbytes
DO
BEGIN curcmd:=byte0;
IF(curcmd=58) OR(curcmd=54)
OR(curcmd=55) THEN
BEGIN curfont:=byte2;
curchar:=byte3
END
ELSE curchar:=rhword
END;
state:=1
END;
11: BEGIN state:= 15;
curchar:=32;
END;
34: BEGIN curbuf:=bufptr+1;
hashentry:=hashpar;
WITH eqtb[hashpar].fourbytes
DO BEGIN curcmd:=byte0;
curchar:=rhword
END
END;
6: BEGIN state:=29;
curbuf:=bufptr+1;
curcmd:=10;
curchar:=32;
END;
20: BEGIN state:=29;
curbuf:=bufptr+1;
GOTO 2
END;
2: alignstate:=alignstate+1;
16, 30: BEGIN state:=1;
alignstate:=alignstate+1
END;
3: alignstate:=alignstate-1;
17, 31: BEGIN state:=1;
alignstate:=alignstate-1
END;
18, 19,
21, 22, 23, 26,
27, 32, 33, 35,
40, 41:state:= 1;
OTHERS:
END
END
ELSE BEGIN BEGIN
IF(loc<>-1)
THEN
BEGIN
inln(loc,buffer,bufptr,brchar,eoff);
curbuf:=1;
IF eoff THEN BEGIN
lsave:=lvl;
print(41);
release(loc);
popinput;
pageendcheck(lsave);
hashentry:=hashpar;
WITH eqtb[hashpar].fourbytes
DO BEGIN curcmd:=byte0;
curchar:=rhword
END;
GOTO 1
END;
IF brchar=0 THEN BEGIN
println(176);
println(177);
printint(recovery.rhword);
print(178);
printint(recovery.lhword+1);
print(58);
FOR j:=1 TO bufptr DO print(buffer[j]);
recovery.lhword:=recovery.lhword-1
END;
IF odd(eqtb[1408].twohalves.rhword)
AND notnonstop THEN traceline(buffer,bufptr);
IF brchar=12 THEN BEGIN recovery.rhword
:=recovery.rhword+1;
print(32);
printint(recovery.rhword);
forcebufferout;
recovery.lhword:=0;
pageendcheck(lvl);
END
ELSE recovery.lhword:=recovery.lhword+1
END
ELSE IF inptr<>0 THEN
BEGIN popinput;
GOTO 0
END
ELSE IF notnonstop THEN BEGIN
println(42);
inlnter(buffer,bufptr,brchar);
curbuf:=1;
WITH curinput DO FOR j:=curbuf
TO bufptr-1 DO outcherr(buffer[j]);
outlnerr;
IF(escapechar=0) AND(buffer[1]<>13)
THEN
BEGIN escapechar:=buffer[1];
eqtb[escapechar+1137].int:=0;
END;
END
ELSE BEGIN
println(175);
quit;
END;
END;
GOTO 2
END
ELSE IF loc<>0 THEN BEGIN
BEGIN curcmd:=mem[loc].twohalves
.byte2;
curchar:=mem[loc].twohalves
.byte3;
loc:=mem[loc].twohalves.lhword
END;
CASE curcmd OF
0:BEGIN
hashentry:=mem[loc].twohalves
.rhword;
WITH eqtb[hashentry].fourbytes
DO
BEGIN curcmd:=byte0;
IF(curcmd=58) OR(curcmd=54)
OR(curcmd=55) THEN
BEGIN curfont:=byte2;
curchar:=byte3
END
ELSE curchar:=rhword
END;
loc:=mem[loc].twohalves.lhword
END;
9: BEGIN
pushinput;
WITH curinput DO
BEGIN loc:=parstack[curbuf+ curchar];
recovery.rhword:=0;
recovery.lhword:=loc;
GOTO 0 END
END;
1: alignstate:=alignstate+1;
2: alignstate:=alignstate-1;
OTHERS:
END
END
ELSE BEGIN poptokenlist;
GOTO 0
END;
IF(alignstate=0) AND((curcmd=4)
OR(curcmd=5))
THEN
BEGIN
aligndelim;
hashentry:=-1;
GOTO 0
END;
1:
END;
PROCEDURE gettok;
BEGIN
hashentry:=-1;
getnext;
IF hashentry>=0
THEN BEGIN curtyp:=0;
curval:=hashentry
END
ELSE BEGIN curtyp:=curcmd;
curval:=curchar
END;
IF curcmd=15
THEN
BEGIN
backinput;
println(179);
error;
curcmd:=2
END
END;
PROCEDURE getncnext;
LABEL 0;
BEGIN
WHILE true DO
BEGIN nonewcontrolseq:=true;
getnext;
nonewcontrolseq:=false;
IF curcmd=0 THEN
BEGIN
println(180);
error
END
ELSE IF curcmd<>16
THEN GOTO 0
ELSE macrocall
END;
0:
END;
PROCEDURE getnctok;
LABEL 0;
BEGIN
WHILE true DO
BEGIN
hashentry:=-1;
nonewcontrolseq:=true;
getnext;
nonewcontrolseq:=false;
IF hashentry<0 THEN BEGIN curtyp:=curcmd;
curval:=curchar;
GOTO 0
END
ELSE BEGIN curtyp:=0;
curval:=hashentry;
IF curcmd=0 THEN
BEGIN
println(180);
error
END
ELSE IF curcmd<>16
THEN GOTO 0
ELSE macrocall
END
END;
0:
END;
FUNCTION scandigit: integer;
FORWARD;
PROCEDURE scanlb;
FORWARD;
PROCEDURE insnum(n: integer);
FORWARD;
FUNCTION scantoks;
LABEL 5,
0;
VAR cur: integer;
p,q: integer;
listhead: integer;
curhash: integer;
unbal: integer;
BEGIN
cur:=curcmd;
curhash:=hashentry;
pagewarning:=defof;
warnindex:=curhash;
scanlb;
listhead:=getavail;
mem[listhead].twohalves.rhword:=0;
p:=listhead;
unbal:=1;
WHILE true DO BEGIN
IF((cur=50) OR(cur=21))
AND((curval>=1137) OR(eqtb[curval].fourbytes
.byte0<>21) OR(q=listhead))
THEN BEGIN
5:
getnctok;
pagewarning:=defof;
warnindex:=curhash;
IF cur=21 THEN
BEGIN
IF curcmd=32 THEN
BEGIN
insnum(kount[scandigit]);
gettok END
ELSE IF(curcmd=49) AND NOT outputdormant
THEN
BEGIN
CASE curchar OF
0: q:=botmark;
1: q:=topmark;
2: q:=firstmark;
OTHERS:
confusion
END;
IF q<>0 THEN insrclist(q);
GOTO 5
END
END
END
ELSE gettok;
IF curcmd=2 THEN
BEGIN unbal:=unbal-1;
IF unbal<=0 THEN GOTO 0
END
ELSE IF curcmd=1 THEN unbal:=unbal+1
;
BEGIN
q:=getavail;
mem[p].twohalves.lhword:=q;
p:=q;
mem[p].twohalves.byte2:=curtyp;
IF curtyp=0 THEN BEGIN q:=getavail;
mem[p].twohalves.lhword:=q;
p:=q;
mem[p].twohalves.rhword:=curval
END
ELSE mem[p].twohalves.byte3:=curval
END
END;
0:;
pagewarning:=ok;
IF cur=22 THEN
BEGIN
q:=getavail;
mem[p].twohalves.lhword:=q;
p:=q;
mem[p].twohalves.byte2:=curtyp;
mem[p].twohalves.byte3:=curval;
getnctok;
IF curcmd<>10 THEN backinput
END;
mem[q].twohalves.lhword:=0;
scantoks:=listhead;
END;
PROCEDURE macrodef(gdef: integer);
LABEL 1;
VAR defplace: integer;
toktyp,tokval: integer;
p,q:integer;
listhead: integer;
npars: integer;
unbal: integer;
t: integer;
BEGIN
gettok;
defplace:=hashentry;
IF defplace<0
THEN BEGIN
backinput;
println(181);
error
END
ELSE BEGIN
listhead:= getavail;
mem[listhead].twohalves.rhword:=0;
p:=getavail;
q:=getavail;
mem[p].twohalves.byte2:=0;
mem[q].twohalves.rhword:=defplace;
mem[p].twohalves.lhword:=q;
mem[listhead].twohalves.lhword:=p;
IF gdef=2
THEN BEGIN p:=q;
curcmd:=21;
q:=scantoks;
mem[q].twohalves.byte2:=14;
mem[q].twohalves.byte3:=1;
mem[p].twohalves.lhword:=q;
END
ELSE BEGIN
npars:=0;
REPEAT
gettok;
IF curcmd<>6 THEN BEGIN toktyp:=curtyp;
tokval:=curval END
ELSE BEGIN gettok;
npars:=npars+1;
IF(curchar-48<>npars) OR(curcmd<>12)
THEN BEGIN
backinput;
println(183);
error
END;
IF(npars>26)
THEN overflow(182,26);
toktyp:=14;
tokval:=0 END;
p:=q;
q:=getavail;
mem[p].twohalves.lhword:=q;
mem[q].twohalves.byte2:=toktyp;
IF toktyp=0 THEN BEGIN p:=q;
q:=getavail;
mem[q].twohalves.rhword:=tokval;
mem[p].twohalves.lhword:=q;
END
ELSE mem[q].twohalves.byte3:=tokval
UNTIL(curcmd=1) OR(curcmd=2)
;
mem[q].twohalves.byte2:=14;
mem[q].twohalves.byte3:=1;
IF curcmd=2
THEN
BEGIN
BEGIN
alignstate:=alignstate+1;
println(184);
error;
END;
GOTO 1 END;
pagewarning:=defof;
warnindex:=defplace;
unbal:=1;
WHILE true DO BEGIN
gettok;
IF curcmd=2 THEN
BEGIN unbal:=unbal-1;
IF unbal<=0 THEN GOTO 1
END
ELSE IF curcmd=1 THEN unbal:=unbal+1
;
IF curcmd<>6 THEN BEGIN toktyp:=curtyp;
tokval:=curval END
ELSE BEGIN gettok;
IF curcmd<>6 THEN BEGIN
IF(curchar>(48+npars)) OR(curchar<49)
THEN
BEGIN
BEGIN
backinput;
println(185);
print(escapechar);
showidname(defplace);
print(46);
error
END;
toktyp:=curtyp;
tokval:=curval END
ELSE BEGIN toktyp:=9;
tokval:=curchar-49
END
END
ELSE BEGIN toktyp:=curtyp;
tokval:=curval
END
END;
p:=q;
q:=getavail;
mem[p].twohalves.lhword:=q;
mem[q].twohalves.byte2:=toktyp;
IF toktyp=0 THEN BEGIN p:=q;
q:=getavail;
mem[q].twohalves.rhword:=tokval;
mem[p].twohalves.lhword:=q;
END
ELSE mem[q].twohalves.byte3:=tokval
END;
1:
mem[q].twohalves.lhword:=0;
pagewarning:=ok END;
IF gdef<>0
THEN
BEGIN t:=curlev;
curlev:=1;
END;
eqdefine(defplace,16,listhead);
IF gdef<>0
THEN curlev:=t;
;
getnctok;
IF curcmd<>10 THEN backinput
END;
END;
PROCEDURE macrocall;
LABEL 0,
1;
VAR maclist: integer;
defplace: integer;
r: integer;
npars: integer;
firsterror: boolean;
ttyp,tval: integer;
ngrps: integer;
prevcmd: integer;
p: integer;
unbal: integer;
j: integer;
BEGIN
defplace:=hashentry;
maclist:=curchar;
pagewarning:=useof;
warnindex:=defplace;
r:=mem[maclist].twohalves.lhword;
IF(eqtb[1408].int<>4194784)
THEN IF odd(eqtb[1408].twohalves.lhword)
THEN
BEGIN println(-1);
dumptokens(r) END;
r:=mem[mem[r].twohalves.lhword].twohalves.lhword;
npars:=0;
firsterror:=true;
ttyp:=mem[r].twohalves.byte2;
IF ttyp=0 THEN
BEGIN r:=mem[r].twohalves.lhword;
tval:=mem[r].twohalves.rhword
END
ELSE tval:=mem[r].twohalves.byte3;
WHILE(ttyp<>14) OR(tval<>1)
DO
BEGIN
r:=mem[r].twohalves.lhword;
IF(ttyp<>14) OR(tval<>0)
THEN BEGIN
gettok;
IF((ttyp<>curtyp) OR(tval<>curval))
AND firsterror THEN
BEGIN
firsterror:=false;
println(188);
print(escapechar);
showidname(defplace);
print(189);
error
END
END
ELSE BEGIN
ttyp:=mem[r].twohalves.byte2;
IF ttyp=0 THEN
BEGIN r:=mem[r].twohalves.lhword;
tval:=mem[r].twohalves.rhword
END
ELSE tval:=mem[r].twohalves.byte3;
IF(ttyp=14)
THEN
ttyp:=250
ELSE r:=mem[r].twohalves
.lhword;
q:=25003;
mem[25003].twohalves.lhword:=0;
ngrps:=0;
gettok;
toktyp:=83;
tokval:=0;
WHILE(curtyp<>ttyp) OR(curval<>tval)
DO
BEGIN
WHILE curcmd=2 DO
BEGIN
alignstate:=alignstate+1;
println(186);
print(escapechar);
showidname(defplace);
print(187);
error;
gettok END;
BEGIN
p:=q;
q:=getavail;
WITH mem[p].twohalves
DO BEGIN byte2:=toktyp;
lhword:=q END;
IF toktyp=0 THEN
BEGIN p:=q;
q:=getavail;
WITH mem[p].twohalves
DO BEGIN lhword:=q;
rhword:=tokval END
END
ELSE mem[p].twohalves.byte3:=tokval;
toktyp:=curtyp;
tokval:=curval
END;
IF curcmd=1 THEN
BEGIN
unbal:=1;
WHILE true DO BEGIN
gettok;
BEGIN
p:=q;
q:=getavail;
WITH mem[p].twohalves
DO BEGIN byte2:=toktyp;
lhword:=q END;
IF toktyp=0 THEN
BEGIN p:=q;
q:=getavail;
WITH mem[p].twohalves
DO BEGIN lhword:=q;
rhword:=tokval END
END
ELSE mem[p].twohalves.byte3:=tokval;
toktyp:=curtyp;
tokval:=curval
END;
IF curcmd=2 THEN
BEGIN unbal:=unbal-1;
IF unbal<=0 THEN GOTO 0
END
ELSE IF curcmd=1 THEN unbal:=unbal+1
END;
0:
END;
ngrps:=ngrps+1;
prevcmd:=curcmd;
IF ttyp=250
THEN GOTO 1
ELSE gettok
END;
1:;
IF(ngrps=1) AND(prevcmd=2)
THEN
BEGIN
mem[p].twohalves.lhword:=0;
freeavail(q);
pstack[npars]:=mem[mem[25003].twohalves
.lhword].twohalves.lhword;
freeavail(mem[25003].twohalves
.lhword) END
ELSE BEGIN
mem[q].twohalves.byte2:=toktyp;
IF toktyp=0 THEN
BEGIN p:=q;
q:=getavail;
mem[q].twohalves.rhword:=tokval;
mem[p].twohalves.lhword:=q
END
ELSE mem[q].twohalves.byte3:=tokval;
pstack[npars]:=mem[25003].twohalves
.lhword;
END;
IF(eqtb[1408].int<>4194784)
THEN IF odd(eqtb[1408].twohalves.lhword)
THEN
BEGIN println(35);
print(npars+49);
print(95);
dumptokens(pstack[npars])
END;
npars:=npars+1
END;
ttyp:=mem[r].twohalves.byte2;
IF ttyp=0 THEN
BEGIN r:=mem[r].twohalves.lhword;
tval:=mem[r].twohalves.rhword
END
ELSE tval:=mem[r].twohalves.byte3
END;
pagewarning:=ok;
WHILE(curinput.state=0) AND(curinput.loc=0)
DO poptokenlist;
IF(parptr+npars)>26 THEN overflow(190,26);
FOR j:=0 TO npars-1 DO parstack[parptr+j]:=pstack[j];
pushinput;
WITH curinput DO
BEGIN
loc:=mem[r].twohalves.lhword;
state:=0;
recovery.rhword:=4;
recovery.lhword:=maclist;
curbuf:=parptr;
parptr:=parptr+npars END;
mem[maclist].twohalves.rhword:=
mem[maclist].twohalves.rhword+1;
END;
FUNCTION scanfilename(fyl: integer):
integer;
LABEL 1;
VAR f: integer;
BEGIN
f:=initfilename(fyl);
IF(f<0) THEN overflow(191,6);
getnctok;
WHILE true DO
CASE appendtoname(curcmd,curchar)
OF
0: GOTO 1;
1: BEGIN f:=(-(f+1));
GOTO 1
END;
2: BEGIN backinput;
error;
getnctok END;
3: getnctok;
OTHERS:
confusion
END;
1:
scanfilename:=f;
END;
PROCEDURE inputfile;
VAR f: integer;
page: integer;
BEGIN
f:=scanfilename(-2);
IF(f<0) THEN
BEGIN
BEGIN
println(192);
printfilename((((65+(57-48))+((-(f+1))))));
error END;
f:=scanfilename(-2) END;
IF NOT(f<0) THEN
BEGIN
pushinput;
print(193);
printfilename(((65+(57-48))+(f))
);
WITH curinput DO
BEGIN state:=29;
loc:=f;
lvl:=curlev;
END;
WITH curinput DO
IF NOT getfirstline(loc,buffer,bufptr,brchar,eoff,page)
THEN
BEGIN
print(41);
release(f);
popinput END
ELSE BEGIN curbuf:=1;
recovery.rhword:=page;
recovery.lhword:=1;
IF(eqtb[1408].int<>4194784)
THEN IF odd(eqtb[1408].twohalves.rhword)
AND notnonstop THEN traceline(buffer,bufptr);
IF nooutputyet THEN BEGIN
declareofil(((65+(57-48))+(f)));
nooutputyet:=false
END
END
END;
END;
PROCEDURE opendigit(d: integer);
VAR f: integer;
BEGIN
f:=scanfilename((65+(d-48)));
sendout[d]:=d-48;
END;
PROCEDURE definefont(fyl: integer);
FORWARD;
PROCEDURE backinput;
VAR p: integer;
BEGIN
p:=getavail;
mem[p].twohalves.byte2:=curtyp;
IF curtyp=0 THEN BEGIN mem[p].twohalves
.lhword:=getavail;
mem[mem[p].twohalves.lhword].twohalves.rhword:=curval END
ELSE mem[p].twohalves.byte3:=curval MOD 256;
IF curcmd=1 THEN alignstate:=alignstate-1
ELSE IF curcmd=2 THEN alignstate:=alignstate+1;
inslist(p);
END;
FUNCTION scandigit;
VAR d: integer;
BEGIN
getnctok;
d:=curchar;
IF(curtyp<>12) OR(NOT((curval>=48)
AND(curval<=57)))
THEN BEGIN
backinput;
println(194);
error;
d:=48
END;
getnctok;
IF curcmd<>10 THEN backinput;
scandigit:=d
END;
PROCEDURE scanlb;
BEGIN
REPEAT getnctok UNTIL curcmd<>10
;
IF curcmd<>1
THEN
BEGIN
backinput;
BEGIN
alignstate:=alignstate+1;
println(184);
error;
END;
END;
END;
FUNCTION scanstring;
LABEL 1;
VAR s: asciistring;
j: integer;
c: asciicode;
q: integer;
p: integer;
head: integer;
i: integer;
BEGIN
scanstring:=false;
producestring(particle,s);
j:=0;
c:=s[0];
WHILE c<>0 DO
BEGIN
getnctok;
BEGIN
IF(c>=65) AND(c<=90) THEN
c:=c+(97-65)
END;
IF(curtyp<>11) OR((curval<>c)
AND(curval<>c-32))
THEN
BEGIN
q:=getavail;
head:=q;
FOR i:=0 TO j-1 DO
BEGIN
p:=q;
q:=getavail;
mem[p].twohalves.byte2:=11;
mem[p].twohalves.byte3:=s[i];
mem[p].twohalves.lhword:=q;
END;
mem[q].twohalves.byte2:=curtyp;
IF curtyp=0 THEN BEGIN p:=q;
q:=getavail;
mem[p].twohalves.lhword:=q;
mem[q].twohalves.rhword:=curval END
ELSE mem[q].twohalves.byte3:=curval;
mem[q].twohalves.lhword:=0;
IF curcmd=1 THEN alignstate:=alignstate-1
ELSE IF curcmd=2 THEN alignstate:=alignstate+1;
inslist(head);
scanstring:=false;
GOTO 1
END;
s[j]:=curval;
j:=j+1;
c:=s[j]
END;
scanstring:=true;
1:
END;
FUNCTION scannumber: integer;
VAR n: integer;
radix: integer;
m: integer;
BEGIN
n:=0;
nbrlength:=0;
nbrsign:=43;
radix:=10;
REPEAT getnctok UNTIL curcmd<>10;
IF(curtyp=12)
AND((curval=43) OR(curval=45))
THEN
BEGIN
nbrsign:=curchar;
REPEAT getnctok UNTIL curcmd<>10
END;
IF(curcmd=12) AND(curval=39)
THEN
BEGIN
radix:=8;
REPEAT getnctok UNTIL curcmd<>10
END;
IF curcmd=32 THEN
BEGIN
n:=kount[scandigit];
getnctok END
ELSE IF curcmd=76 THEN BEGIN
m:=curchar;
n:=scannumber;
m:=1137+m+n;
IF(n<0) OR(n>255) OR(m>1429)
THEN
BEGIN
println(195);
error;
n:=0;
END;
IF m<=1264 THEN n:=eqtb[m].int
ELSE IF m<=1392 THEN WITH
eqtb[m+1265].fourbytes
DO n:=((byte2
DIV 8)*4+(byte2
MOD 8))*128+byte3
ELSE IF m=1409 THEN n:=round(eqtb[1409].pts)
ELSE IF m=1419 THEN
WITH eqtb[1419].fourbytes DO
n:=((byte0*128+byte1)*4+byte2)*128+byte3
ELSE IF m=1408 THEN
BEGIN
n:=((eqtb[1408].twohalves.lhword DIV 8)*512
+(eqtb[1408].twohalves.rhword DIV 8));
n:=n*2;
IF odd(eqtb[1408].twohalves.rhword DIV 4)
THEN n:=n+1;
n:=n*2;
IF odd(eqtb[1408].twohalves.rhword)
THEN n:=n+1;
n:=n*2;
IF odd(eqtb[1408].twohalves.lhword)
THEN n:=n+1;
n:=n*2;
IF odd(eqtb[1408].twohalves.lhword DIV 4)
THEN n:=n+1;
n:=n*2;
IF odd(eqtb[1408].twohalves.lhword DIV 2)
THEN n:=n+1;
n:=n*2;
IF odd(eqtb[1408].twohalves.rhword DIV 2)
THEN n:=n+1;
END
ELSE n:=eqtb[m].int;
getnctok
END
ELSE IF curcmd>12 THEN BEGIN
backinput;
println(196);
error;
getnctok
END
ELSE IF((NOT((curtyp=12) AND
((curval>=48) AND(curval<=57))
)) AND((curtyp<>12) OR(curval<>46))
) THEN
BEGIN n:=curchar;
getnctok
END
ELSE WHILE((curtyp=12) AND((curval>=48)
AND(curval<=57)))
DO
BEGIN
n:=radix*n+curchar-48;
nbrlength:=nbrlength+1;
getnctok
END;
IF curcmd<>10 THEN backinput;
scannumber:=n;
END;
FUNCTION scanreal: real;
VAR x,y: real;
i: integer;
BEGIN
x:=scannumber;
getnctok;
IF(curtyp=12) AND(curval=46)
THEN
BEGIN
y:=scannumber;
FOR i:=1 TO nbrlength DO y:=y/10.0;
x:=x+y;
END
ELSE backinput;
scanreal:=x;
END;
FUNCTION boxdim(j: integer): real;
VAR k: integer;
BEGIN k:=scandigit;
IF savedbox[k]<>0 THEN
boxdim:=mem[savedbox[k]+j].pts
ELSE boxdim:=0.0;
END;
FUNCTION scanlength;
VAR x: real;
sign: real;
warn: boolean;
n: integer;
j: integer;
d: real;
curfnt: integer;
BEGIN
warn:=true;
x:=scannumber;
IF nbrsign=45 THEN sign:=-1.0
ELSE sign:=+1.0;
getnctok;
IF(curtyp=12) AND(curval=46)
THEN
BEGIN
n:=scannumber;
d:=1;
FOR j:=1 TO nbrlength DO d:=d*10.0;
x:=x+n/d;
END
ELSE backinput;
IF dimmode<=0 THEN BEGIN
IF scanstring(335) THEN x:=x*1000/eqtb[1420].int;
IF scanstring(336) THEN
ELSE
IF scanstring(337) THEN x:=x/0.013837
ELSE IF scanstring(338) THEN
x:=x*12.0
ELSE IF scanstring(339)
THEN x:=x/(0.013837*2.54)
ELSE
IF scanstring(340) THEN x:=x/(0.013837*25.4)
ELSE IF scanstring(341) THEN
x:=x/(72*0.013837)
ELSE IF scanstring(342)
THEN x:=x/(0.013837*2540)
ELSE
IF scanstring(343) THEN
x:=x*(1.0/(26.6*2.54*0.013837))
ELSE IF scanstring(344) THEN
x:=x*(12.0/(26.6*2.54*0.013837))
ELSE IF scanstring(345) THEN
x:=x*pagemem[6]
ELSE IF scanstring(346)
THEN BEGIN
curfnt:=eqtb[0].fourbytes.rhword;
IF curfnt<=63 THEN
x:=x*fmem[parbase[curfnt]+5].pts
END
ELSE IF scanstring(347) THEN BEGIN
curfnt:=eqtb[0].fourbytes.rhword;
IF curfont<=63 THEN x:=x*fmem[parbase[curfnt]+4].pts
END
ELSE IF scanstring(348) THEN x:=x*boxdim(3)
ELSE IF scanstring(349) THEN x:=x*boxdim(2)
ELSE IF scanstring(350) THEN x:=x*boxdim(4)
ELSE IF(dimmode<0) AND scanstring(351)
THEN
BEGIN warn:=false;
x:=x*100000.0;
IF scanstring(108) THEN
BEGIN x:=x*100000.0;
IF scanstring(108) THEN x:=x*100000.0;
END;
END
ELSE BEGIN println(352);
error
END;
IF(dimmode<0) AND warn AND(x>32767)
THEN BEGIN
println(353);
error
END
END
ELSE IF NOT scanstring(334) THEN
BEGIN println(354);
error
END;
getnctok;
IF curcmd<>10 THEN backinput;
scanlength:=x*sign;
END;
FUNCTION scanglue: integer;
VAR p: integer;
d: integer;
BEGIN
d:=dimmode;
p:=getnode(4);
mem[p].twohalves.rhword:=0;
mem[p+1].pts:=scanlength;
IF d=0 THEN dimmode:=-1;
IF scanstring(355) THEN mem[p+2].pts
:=scanlength
ELSE mem[p+2].pts:=0.0;
IF scanstring(356) THEN mem[p+3].pts
:=scanlength
ELSE mem[p+3].pts:=0.0;
dimmode:=d;
scanglue:=p
END;
PROCEDURE scanspec;
LABEL 3;
VAR
v: real;
c: integer;
BEGIN
IF scanstring(357) THEN
BEGIN
getnctok;
IF curcmd<>10 THEN backinput;
IF scanstring(359) THEN
IF mode=-1 THEN v:=pagemem[1]
ELSE v:=pagemem[0]
ELSE v:=scanlength;
c:=0;
GOTO 3;
END
ELSE IF mode=-84 THEN
IF scanstring(358) THEN
BEGIN
getnctok;
IF curcmd<>10 THEN backinput;
IF scanstring(360) THEN v:=pagemem[0]
ELSE v:=scanlength;
c:=2;
GOTO 3;
END;
c:=1;
IF scanstring(361) THEN v:=scanlength
ELSE v:=0;
3:
REPEAT getnctok UNTIL curcmd<>10;
IF curcmd<>1 THEN
BEGIN
backinput;
BEGIN
alignstate:=alignstate+1;
println(184);
error;
END
END;
savestack[saveptr].pts:=v;
WITH savestack[saveptr+1].fourbytes
DO rhword:=c;
saveptr:=saveptr+2;
END;
FUNCTION scanfont(usingit: boolean):
integer;
LABEL 0;
VAR f: integer;
fntnam: asciistring;
BEGIN
WHILE true DO BEGIN
getnctok;
f:=curval MOD 64;
IF curcmd>=14 THEN BEGIN
backinput;
println(362);
error
END
ELSE GOTO 0
END;
0:;
getnctok;
IF curcmd<>10 THEN backinput;
producestring((-(f)-2),fntnam);
IF usingit AND(fntnam[0]=0)
THEN BEGIN
println(363);
error
END;
IF(NOT usingit) OR(fntnam[0]=0)
THEN BEGIN
REPEAT getnctok UNTIL curcmd<>10;
IF(curchar<>61) AND(curchar<>95)
THEN
BEGIN backinput;
println(364);
error;
END;
REPEAT getnctok UNTIL curcmd<>10;
backinput;
definefont(f)
END;
scanfont:=f;
END;
PROCEDURE scandelim(VAR delimiters: bytes4);
VAR n: integer;
BEGIN
getnctok;
IF(curcmd=12) AND(delimtable[curchar].byte0<>255)
THEN delimiters:=delimtable[curchar]
ELSE IF(curcmd=58) AND((curfont MOD 8)=2) AND
(curchar>=98) AND(curchar<=107) THEN
WITH delimiters DO
BEGIN byte0:=2;
byte1:=curchar;
byte2:=3;
byte3:=(curchar+34) MOD 128 END
ELSE IF curcmd=27 THEN WITH delimiters DO
BEGIN n:=scannumber;
byte3:=n MOD 128;
n:=n DIV 128;
byte2:=n MOD 4;
n:=n DIV 4;
byte1:=n MOD 128;
n:=n DIV 128;
byte0:=n MOD 4
END
ELSE BEGIN
backinput;
println(365);
error;
WITH delimiters DO BEGIN byte0
:=0;
byte1:=0;
byte2:=0;
byte3:=0 END
END
END;
FUNCTION scanrulespec: integer;
LABEL 0;
VAR p: integer;
BEGIN
p:=getnode(5);
mem[p].twohalves.byte2:=2;
mem[p+1].twohalves.lhword:=0;
IF curcmd=47 THEN
BEGIN
mem[p+3].pts:=-100000.0;
mem[p+4].pts:=0.4;
mem[p+2].pts:=0.0
END
ELSE
BEGIN
mem[p+3].pts:=0.4;
mem[p+4].pts:=-100000.0;
mem[p+2].pts:=-100000.0
END;
WHILE true DO
IF scanstring(366) THEN mem[p+3].pts
:=scanlength
ELSE IF scanstring(367) THEN mem[p+4].pts
:=scanlength
ELSE IF scanstring(368) THEN mem[p+2].pts
:=scanlength
ELSE GOTO 0;
0:;
scanrulespec:=p
END;
PROCEDURE passblock;
LABEL 0;
VAR unbal: integer;
BEGIN
unbal:=0;
WHILE true DO BEGIN
gettok;
IF curcmd=2 THEN
BEGIN unbal:=unbal-1;
IF unbal<=0 THEN GOTO 0
END
ELSE IF curcmd=1 THEN unbal:=unbal+1
END;
0:;
IF unbal<0 THEN BEGIN alignstate:=alignstate+1;
BEGIN
alignstate:=alignstate+1;
println(184);
error;
END
END;
getnctok;
IF curcmd<>10 THEN backinput;
END;
PROCEDURE insnum;
LABEL 0;
VAR p,q: integer;
romchar: asciicode;
j: integer;
k: integer;
BEGIN
IF n>=0 THEN BEGIN
p:=0;
REPEAT
q:=getavail;
WITH mem[q].twohalves
DO
BEGIN byte2:=12;
byte3:=(n MOD 10)+48;
lhword:=p END;
p:=q;
n:=n DIV 10 UNTIL n=0
END
ELSE BEGIN
romchar:=0;
p:=25003;
j:=1;
n:=-n;
WHILE true DO BEGIN
WHILE n>=romval[j] DO
BEGIN
q:=getavail;
mem[p].twohalves.byte2:=11;
mem[p].twohalves.byte3:=romchar;
mem[p].twohalves.lhword:=q;
p:=q;
romchar:=romlet[j];
n:=n-romval[j]
END;
IF n=0 THEN GOTO 0;
k:=j+1+(j MOD 2);
IF(n+romval[k]>=romval[j])
THEN
BEGIN
q:=getavail;
mem[p].twohalves.byte2:=11;
mem[p].twohalves.byte3:=romchar;
mem[p].twohalves.lhword:=q;
p:=q;
romchar:=romlet[k];
n:=n+romval[k]
END
ELSE j:=j+1
END;
0:
mem[p].twohalves.byte2:=11;
mem[p].twohalves.byte3:=romchar;
mem[p].twohalves.lhword:=0;
p:=mem[25003].twohalves.lhword
END;
inslist(p)
END;
PROCEDURE scancond(b: boolean);
BEGIN
IF b THEN BEGIN
scanlb;
newsavelevel(3)
END
ELSE BEGIN
passblock;
getnctok;
IF curcmd<>35 THEN
BEGIN
backinput;
println(369);
print(escapechar);
print(370);
error
END;
scanlb;
newsavelevel(17)
END
END;
PROCEDURE showruleformat(x: real);
BEGIN
IF x>-100000.0 THEN printreal(x)
ELSE print(197)
END;
PROCEDURE dumpnodelist(p:integer;
indent:asciistring;
len,thresh,n:integer);
LABEL 0;
VAR t,l,c,i: integer;
sa: real;
BEGIN
IF len>thresh THEN GOTO 0;
c:=0;
WHILE p<>0 DO
BEGIN
println(-1);
FOR i:=0 TO len DO print(indent[i]);
IF(p<0) OR(p>=49152) THEN
BEGIN
print(200);
GOTO 0;
END;
c:=c+1;
IF c>n THEN BEGIN
print(201);
GOTO 0;
END;
IF(p>25000) THEN
WITH mem[p].twohalves DO
BEGIN
print(198);
IF byte2<=58 THEN print(byte2+64)
ELSE print(byte2);
print(32);
IF(byte3>=33) AND(byte3<=122) THEN print(byte3)
ELSE printoctal(byte3)
END
ELSE IF mem[p].twohalves.byte2>13 THEN print(199)
ELSE BEGIN t:=mem[p].twohalves.byte2;
l:=mem[p+1].twohalves.lhword;
CASE t OF
0: BEGIN print(202);
print(40);
printreal(mem[p+4].pts);
print(216);
printreal(mem[p+2].pts);
print(217);
printreal(mem[p+3].pts);
IF mem[p+6].pts<>0 THEN
BEGIN print(218);
printreal(mem[p+6].pts)
END;
IF mem[p+5].pts<>0 THEN
BEGIN print(219);
printreal(mem[p+5].pts);
END;
indent[len+1]:=46;
dumpnodelist(l,indent,len+1,thresh,n)
END;
1: BEGIN print(203);
print(40);
printreal(mem[p+4].pts);
print(216);
printreal(mem[p+2].pts);
print(217);
printreal(mem[p+3].pts);
IF mem[p+6].pts<>0 THEN
BEGIN print(218);
printreal(mem[p+6].pts)
END;
IF mem[p+5].pts<>0 THEN
BEGIN print(219);
printreal(mem[p+5].pts);
END;
indent[len+1]:=46;
dumpnodelist(l,indent,len+1,thresh,n)
END;
2: BEGIN print(204);
print(40);
showruleformat(mem[p+4].pts);
print(220);
showruleformat(mem[p+2].pts);
print(221);
showruleformat(mem[p+3].pts)
END;
3: dumpext(p);
4: BEGIN print(205);
IF l<49152 THEN
BEGIN print(32);
IF t=12 THEN
BEGIN
IF mem[l].twohalves.byte3=1 THEN print(222)
ELSE print(223);
IF mem[l].twohalves.byte2=2 THEN print(224)
ELSE IF mem[l].twohalves.byte2=1 THEN print(225);
END;
printreal(mem[l+1].pts);
IF mem[l+2].pts<>0 THEN
BEGIN print(226);
printreal(mem[l+2].pts)
END;
IF mem[l+3].pts<>0 THEN
BEGIN print(227);
printreal(mem[l+3].pts);
END;
IF t=12 THEN
BEGIN print(228);
printreal(mem[l+4].pts);
indent[len+1]:=46;
dumpnodelist(mem[l].twohalves
.lhword,indent,len+1,thresh,n)
END
END
ELSE print(229)
END;
5: BEGIN print(206);
IF(mem[l].twohalves.byte2<>2) THEN
BEGIN sa:=mem[l+5].pts;
mem[l+5].pts:=0;
IF(t>0) THEN print(207)
ELSE IF(t<0) THEN print(208);
END;
indent[len+1]:=46;
dumpnodelist(l,indent,len+1,thresh,n);
IF(mem[l].twohalves.byte2<>2) THEN mem[l+5].pts:=sa;
END;
6: BEGIN print(209);
printreal(mem[p+1].pts)
END;
7: BEGIN print(210);
printint(mem[p+1].int)
END;
8: BEGIN print(211);
printint(mem[p+1].int)
END;
9: BEGIN IF mem[p].twohalves.byte3<>0 THEN print(212);
IF mem[p].twohalves.byte3<>1 THEN
WITH mem[p+1].twohalves DO
BEGIN
print(198);
IF byte2<=58 THEN print(byte2+64)
ELSE print(byte2);
print(32);
IF(byte3>=33) AND(byte3<=122) THEN print(byte3)
ELSE printoctal(byte3)
END
END;
10: BEGIN print(213);
printint(mem[p].twohalves.byte3);
END;
11: BEGIN print(214);
dumptokens(mem[l].twohalves.lhword);
print(126)
END;
12: IF l<49152 THEN
BEGIN print(32);
IF t=12 THEN
BEGIN
IF mem[l].twohalves.byte3=1 THEN print(222)
ELSE print(223);
IF mem[l].twohalves.byte2=2 THEN print(224)
ELSE IF mem[l].twohalves.byte2=1 THEN print(225);
END;
printreal(mem[l+1].pts);
IF mem[l+2].pts<>0 THEN
BEGIN print(226);
printreal(mem[l+2].pts)
END;
IF mem[l+3].pts<>0 THEN
BEGIN print(227);
printreal(mem[l+3].pts);
END;
IF t=12 THEN
BEGIN print(228);
printreal(mem[l+4].pts);
indent[len+1]:=46;
dumpnodelist(mem[l].twohalves
.lhword,indent,len+1,thresh,n)
END
END
ELSE print(229);
13: BEGIN print(215);
print(40);
printreal(mem[p+4].pts);
print(216);
printreal(mem[p+2].pts);
print(217);
printreal(mem[p+3].pts);
IF mem[p+6].pts<>0 THEN
BEGIN print(218);
printreal(mem[p+6].pts)
END;
IF mem[p+5].pts<>0 THEN
BEGIN print(219);
printreal(mem[p+5].pts);
END;
indent[len+1]:=46;
dumpnodelist(l,indent,len+1,thresh,n)
END;
OTHERS:
confusion
END
END;
p:=mem[p].twohalves.lhword;
END;
0:
END;
PROCEDURE dsnodelist(p: integer);
VAR l,q: integer;
BEGIN
WHILE p<>0 DO
BEGIN
q:=mem[p].twohalves.lhword;
IF(p>25000) THEN freeavail(p)
ELSE BEGIN l:=mem[p+1].twohalves.lhword;
CASE mem[p].twohalves.byte2
OF
7, 8, 9, 10, 6: freenode(p,2);
5: BEGIN dsnodelist(l);
freenode(p,2);
END;
0, 1: BEGIN dsnodelist(l);
freenode(p,7);
END;
2: freenode(p,5);
4: BEGIN delgluelink(l);
freenode(p,2) END;
3: destroyext(p);
12: BEGIN dsnodelist(mem[l].twohalves
.lhword);
freenode(l,5);
freenode(p,2) END;
11: BEGIN delrclink(l);
freenode(p,2) END;
OTHERS:
confusion
END;
END;
p:=q;
END;
END;
PROCEDURE tracedump(p: integer);
VAR n: integer;
indent: asciistring;
BEGIN
IF(eqtb[1408].twohalves.lhword DIV 8)<>0 THEN
n:=(eqtb[1408].twohalves.lhword DIV 8)
ELSE n:=5;
dumpnodelist(p,indent,-1,(eqtb[1408].twohalves.rhword DIV 8),n)
END;
FUNCTION boxcopy(p: integer):
integer;
LABEL 2,3,4,1;
VAR q,t,l,m,r,hd: integer;
BEGIN
hd:=getavail;
q:=hd;
WHILE p<>0 DO
BEGIN
IF(p>25000) THEN
BEGIN r:=getavail;
GOTO 2
END
ELSE BEGIN
t:=mem[p].twohalves.byte2;
l:=mem[p+1].twohalves.lhword;
CASE t OF
0, 1, 13:
BEGIN r:=getnode(7);
mem[r+5].pts:=mem[p+5].pts;
mem[r+6].pts:=mem[p+6].pts;
GOTO 4
END;
2: BEGIN r:=getnode(5);
GOTO 4
END;
7, 8, 9, 10, 6:
BEGIN r:=getnode(2);
mem[r+1]:=mem[p+1];
GOTO 2
END;
4, 11: BEGIN mem[mem[p+1].twohalves.lhword].twohalves.rhword:=
mem[mem[p+1].twohalves.lhword].twohalves.rhword+1;
r:=getnode(2);
mem[r+1]:=mem[p+1];
GOTO 2
END;
3: BEGIN r:=copyext(p);
GOTO 1 END;
5: BEGIN r:=getnode(2);
GOTO 3 END;
12: BEGIN m:=getnode(5);
r:=getnode(2);
mem[r].twohalves.byte2:=12;
mem[r+1].twohalves.lhword:=m;
mem[m]:=mem[l];
mem[m].twohalves.lhword:=boxcopy(mem[l].twohalves.lhword);
mem[m+1].pts:=mem[l+1].pts;
mem[m+2].pts:=mem[l+2].pts;
mem[m+3].pts:=mem[l+3].pts;
mem[m+4].pts:=mem[l+4].pts;
GOTO 1
END;
OTHERS:
confusion
END;
END;
4:
mem[r+4]:=mem[p+4];
mem[r+3]:=mem[p+3];
mem[r+2]:=mem[p+2];
3:
mem[r+1].twohalves.lhword:=boxcopy(mem[p+1].twohalves
.lhword);
2:
mem[r]:=mem[p];
1:
mem[q].twohalves.lhword:=r;
q:=r;
p:=mem[p].twohalves.lhword;
END;
mem[q].twohalves.lhword:=0;
q:=mem[hd].twohalves.lhword;
freeavail(hd);
boxcopy:=q
END;
FUNCTION testpagebreak(penalt:
real): boolean;
LABEL 1,0;
VAR glue,badness,trueht: real;
BEGIN
IF 25002=pagetail THEN GOTO 1;
trueht:=pageheight;
IF(emptypage=0) OR(NOT insabsent[0])
THEN
trueht:=trueht+pageinsdepth[1];
IF NOT insabsent[0] THEN trueht:=trueht+pagedepth;
IF trueht>pagesize THEN
BEGIN
glue:=pageshrink;
IF glue<=0.0001 THEN glue:=0.0001;
IF trueht-glue>pagesize THEN
BEGIN
IF curbreak=0 THEN curbreak:=pagetail;
testpagebreak:=true;
GOTO 0;
END;
badness:=(trueht-pagesize)/glue;
END
ELSE BEGIN
glue:=pagestretch;
IF glue<=0.0001 THEN glue:=0.0001;
badness:=(pagesize-trueht)/glue;
END;
badness:=badness*badness*badness+penalt;
IF badness<=curbadness THEN
BEGIN curbreak:=pagetail;
curbadness:=badness;
END;
1:
testpagebreak:=false;
0:
END;
PROCEDURE dmpnoadlist(p: integer;
indent: asciistring;
len,thresh,n: integer);
FORWARD;
PROCEDURE dmpnoadfield(p:bytes4;
indent:asciistring;
len,thresh,n:integer);
VAR i: integer;
BEGIN
IF len<=thresh THEN
WITH p DO
CASE byte0
OF
1: dumpnodelist(rhword,indent,len,thresh,n);
2: BEGIN
println(-1);
FOR i:=0 TO len DO print(indent[i]);
printoctal(byte3);
print(64);
printint((byte2
MOD 8))
END;
3: dmpnoadlist(rhword,indent,len,thresh,n);
0:;
OTHERS:
confusion
END
END;
PROCEDURE dmpnoadlist;
LABEL 0;
VAR c,t,l,i: integer;
BEGIN
IF len>thresh THEN GOTO 0;
c:=0;
WHILE p<>0 DO
BEGIN
println(-1);
FOR i:=0 TO len DO print(indent[i]);
IF(p<0) OR(p>=49152) THEN
BEGIN
print(200);
GOTO 0;
END;
c:=c+1;
IF c>n THEN BEGIN
print(201);
GOTO 0;
END;
BEGIN t:=mem[p].twohalves.byte2;
CASE t OF
0, 1, 2, 3, 4, 5, 6,
7, 8, 9, 10, 11:
BEGIN
CASE t OF
0: print(236);
1: print(237);
2: print(238);
3: print(239);
4: print(240);
5: print(241);
6: print(242);
7: print(243);
8: print(244);
9: print(245);
10: print(246);
11: print(247)
END;
IF mem[p].twohalves.byte3<>0 THEN
printint(mem[p].twohalves.byte3)
ELSE IF t=10 THEN
WITH mem[p+4].fourbytes DO
BEGIN printoctal(byte3);
print(64);
printint((byte2
MOD 8))
END;
IF t=11 THEN
BEGIN
printreal(mem[p+1].pts);
print(230);
BEGIN printoctal(mem[p+4].fourbytes.byte1);
print(64);
printint(mem[p+4].fourbytes.byte0);
print(45);
printoctal(mem[p+4].fourbytes.byte3);
print(64);
printint(mem[p+4].fourbytes.byte2)
END;
print(231);
BEGIN printoctal(mem[p+5].fourbytes.byte1);
print(64);
printint(mem[p+5].fourbytes.byte0);
print(45);
printoctal(mem[p+5].fourbytes.byte3);
print(64);
printint(mem[p+5].fourbytes.byte2)
END;
END
ELSE BEGIN
indent[len+1]:=46;
dmpnoadfield(mem[p+1].fourbytes
,indent,len+1,thresh,n);
END;
IF mem[p+2].fourbytes.byte0<>0 THEN
BEGIN
indent[len+1]:=94;
dmpnoadfield(mem[p+2].fourbytes
,indent,len+1,thresh,n);
END;
IF mem[p+3].fourbytes.byte0<>0 THEN
BEGIN
indent[len+1]:=1;
dmpnoadfield(mem[p+3].fourbytes
,indent,len+1,thresh,n);
END;
END;
12:
BEGIN print(232);
BEGIN printoctal(mem[p+1].fourbytes.byte1);
print(64);
printint(mem[p+1].fourbytes.byte0);
print(45);
printoctal(mem[p+1].fourbytes
.byte3);
print(64);
printint(mem[p+1].fourbytes.byte2)
END;
END;
13:
BEGIN print(233);
BEGIN printoctal(mem[p+1].fourbytes
.byte1);
print(64);
printint(mem[p+1].fourbytes.byte0);
print(45);
printoctal(mem[p+1].fourbytes.byte3);
print(64);
printint(mem[p+1].fourbytes.byte2)
END;
END;
14: BEGIN l:=mem[p+1].fourbytes.rhword;
IF l<>0 THEN dumpnodelist(l,indent,len,thresh,n)
END;
15:
BEGIN print(234);
printint(mem[p].twohalves.byte3);
END;
OTHERS:
print(235)
END
END;
p:=mem[p].twohalves.lhword;
END;
0:
END;
PROCEDURE tracedmpmath(p: integer);
VAR indent: asciistring;
n: integer;
BEGIN
IF(eqtb[1408].twohalves.lhword
DIV 8)<>0 THEN
n:=(eqtb[1408].twohalves.lhword DIV 8)
ELSE n:=5;
dmpnoadlist(p,indent,-1,(eqtb[1408].twohalves.rhword
DIV 8),n);
END;
PROCEDURE pushnest;
BEGIN
IF nestptr>=40 THEN overflow(248,40);
modestack[nestptr]:=mode;
headstack[nestptr]:=head;
curndstack[nestptr]:=curnode;
auxstack[nestptr]:=aux;
nestptr:=nestptr+1;
head:=getavail;
curnode:=head
END;
PROCEDURE popnest;
BEGIN
nestptr:=nestptr-1;
freeavail(head);
mode:=modestack[nestptr];
head:=headstack[nestptr];
curnode:=curndstack[nestptr];
aux:=auxstack[nestptr]
END;
PROCEDURE showmode(m: integer);
BEGIN
IF m>0 THEN
CASE(m-1)DIV(83) OF
0: print(249);
1: print(250);
2: print(251);
OTHERS:
confusion
END
ELSE CASE(-m-1)DIV(83) OF
0: print(252);
1: print(253);
2: print(254);
OTHERS:
confusion
END
END;
PROCEDURE dumpactivities;
VAR ptr,md: integer;
BEGIN
pushnest;
popnest;
FOR ptr:=nestptr DOWNTO 0 DO
BEGIN
println(261);
md:=modestack[ptr];
showmode(md);
IF(abs(md)=1) AND (auxstack[ptr].pts<>
-(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0)) THEN
BEGIN print(255);
printreal(auxstack[ptr].pts);
END;
IF abs(md)=84 THEN
BEGIN print(256);
printreal(auxstack[ptr].pts);
END;
IF abs(md)=167 THEN
BEGIN
IF(auxstack[ptr].int<>0) AND (auxstack[ptr].pts<>
-(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0)) THEN
BEGIN
print(257);
tracedmpmath(auxstack[ptr].int);
println(-1);
END;
tracedmpmath(mem[headstack[ptr]].twohalves.lhword);
END
ELSE tracedump(mem[headstack[ptr]].twohalves.lhword);
END;
println(261);
print(258);
tracedump(mem[25002].twohalves
.lhword);
IF waitingtail<>25000 THEN
BEGIN
println(261);
print(259);
tracedump(mem[25000].twohalves
.lhword)
END;
println(261);
print(260);
printint(curlev-1)
END;
FUNCTION charwd(f:integer;
c: asciicode):real;
VAR displacement: integer;
BEGIN
displacement:=fontinfo[f,c].byte0;
charwd:=fmem[wdbase[f]+displacement].pts
END;
FUNCTION charht(f:integer;
c: asciicode):real;
VAR displacement: integer;
BEGIN
displacement:=fontinfo[f,c].byte1
DIV 16;
charht:=fmem[htbase[f]+displacement].pts
END;
FUNCTION chardp(f:integer;
c: asciicode):real;
VAR displacement: integer;
BEGIN
displacement:=fontinfo[f,c].byte1 MOD 16;
chardp:=fmem[dpbase[f]+displacement].pts
END;
FUNCTION charic(f:integer;
c: asciicode):real;
VAR displacement: integer;
BEGIN
displacement:=fontinfo[f,c].byte2
DIV 4;
charic:=fmem[icbase[f]+displacement].pts
END;
PROCEDURE definefont;
LABEL 50, 31, 0;
VAR f: integer;
oldnam,newnam: asciistring;
p: integer;
j: integer;
atclause: boolean;
psize: real;
ff: integer;
BEGIN
producestring((-(fyl)-2),oldnam);
IF(parbase[fyl]<>0)
THEN f:=64
ELSE f:=fyl;
31:
f:=scanfilename(f);
REPEAT getnctok UNTIL(curcmd<>10);
backinput;
atclause:=scanstring(262);
IF atclause THEN psize:=scanlength
ELSE psize:=0.0;
IF(psize<0) THEN BEGIN
println(263);
error;
psize:=(0.000001*0.000001*0.00000001);
END;
IF(f<0) THEN BEGIN BEGIN
println(192);
printfilename(((-(f+1))));
error END;
f:=-f;
GOTO 31;
END;
ff:=appndstring((-(f)-2),264);
IF atclause THEN
ff:=appndreal((-(f)-2),psize)
ELSE ff:=appndstring((-(f)-2),42);
ff:=appndstring((-(f)-2),265);
IF(oldnam[0]<>0)
THEN
BEGIN
producestring((-(f)-2),newnam);
j:=0;
WHILE(oldnam[j]=newnam[j]) AND
(oldnam[j]<>0) DO j:=j+1;
IF(oldnam[j]<>0) OR(newnam[j]<>0)
THEN
BEGIN println(266);
printfilename(fyl);
print(46);
error;
GOTO 50;
END
END
ELSE IF f=64 THEN
ff:=appndstring((-(fyl)-2),(-(f)-2));
IF(NOT(parbase[fyl]<>0)) THEN
CASE readfontinfo(fyl,fontinfo,fmem,
wdbase,htbase,dpbase,icbase,lgbase,krbase,extbase,parbase,
fcksum,fpfb,fmag,fpfi,fmemptr,psize,atclause)
OF
0:;
1: overflow(267,6400);
2: BEGIN
println(268);
print(269);
error;
END;
OTHERS:
confusion
END;
p:=30+fyl*4;
mem[p].twohalves.rhword:=50000;
mem[p+1].pts:= fmem[parbase[fyl]+1].pts;
mem[p+2].pts:= fmem[parbase[fyl]+2].pts;
mem[p+3].pts:= fmem[parbase[fyl]+3].pts;
50:
END;
FUNCTION nullbox: integer;
VAR b: integer;
BEGIN
b:=getnode(7);
mem[b].twohalves.byte2:=0;
mem[b+3].pts:=0.0;
mem[b+4].pts:=0.0;
mem[b+2].pts:=0.0;
mem[b+5].pts:=0.0;
mem[b+6].pts:=0.0;
nullbox:=b
END;
FUNCTION hpackage(head: integer;
desiredwidth: real;
xpand: boolean): integer;
LABEL 10;
VAR t: integer;
r: real;
p,q,prevp: integer;
curins: integer;
ht,dp,wd: real;
delta: real;
f,c: integer;
BEGIN
mem[25009].twohalves.lhword:=0;
curins:=25009;
prevp:=head;
p:=mem[head].twohalves.lhword;
ht:=0.0;
dp:=0.0;
wd:=0.0;
str:=0.0;
shr:=0.0;
WHILE p<>0 DO
BEGIN
IF(p>25000) THEN BEGIN
WITH mem[p].twohalves
DO BEGIN f:=byte2;
c:=byte3;
END;
WITH fontinfo[f,c] DO
BEGIN
wd:=wd+fmem[wdbase[f]+byte0].pts;
r:=fmem[htbase[f]+(byte1 DIV 16)].pts;
IF r>ht THEN ht:=r;
r:=fmem[dpbase[f]+(byte1 MOD 16)].pts;
IF r>dp THEN dp:=r
END
END
ELSE CASE mem[p].twohalves.byte2
OF
0, 1, 2, 13:
BEGIN
wd:=wd+mem[p+3].pts;
IF mem[p].twohalves.byte2<>2 THEN r:=mem[p+5].pts
ELSE
r:=0.0;
IF(mem[p+4].pts-r)>ht THEN
ht:=mem[p+4].pts-r;
IF(mem[p+2].pts+r)>dp THEN
dp:=mem[p+2].pts+r
END;
3: hpackext(p);
6: wd:=wd+mem[p+1].pts;
4: BEGIN
t:=mem[p+1].twohalves.lhword;
wd:=wd+mem[t+1].pts;
str:=str+mem[t+2].pts;
shr:=shr+mem[t+3].pts
END;
5, 7, 8:;
9: IF mem[p].twohalves.byte3=0 THEN BEGIN p:=p+1;
BEGIN
WITH mem[p].twohalves
DO BEGIN f:=byte2;
c:=byte3;
END;
WITH fontinfo[f,c] DO
BEGIN
wd:=wd+fmem[wdbase[f]+byte0].pts;
r:=fmem[htbase[f]+(byte1 DIV 16)
].pts;
IF r>ht THEN ht:=r;
r:=fmem[dpbase[f]+(byte1 MOD 16)
].pts;
IF r>dp THEN dp:=r
END
END;
p:=p-1 END;
10, 12, 11: BEGIN q:=p;
p:=mem[p].twohalves.lhword;
IF((mem[q].twohalves.byte2=10) AND(mem[q].twohalves.byte3=0))
OR((mem[q].twohalves.byte2=12) AND(mem[q+1].twohalves.lhword=0))
THEN freenode(q,2)
ELSE BEGIN
mem[curins].twohalves.lhword:=q;
curins:=q;
mem[curins].twohalves.lhword:=0
END;
mem[prevp].twohalves.lhword:=p;
GOTO 10
END;
OTHERS:
confusion
END;
prevp:=p;
p:=mem[p].twohalves.lhword;
10:
END;
p:=getnode(7);
mem[p].twohalves.byte2:=0;
mem[p+1].twohalves.lhword:=mem[head].twohalves.lhword;
IF xpand THEN desiredwidth:=wd+desiredwidth;
mem[p+3].pts:=desiredwidth;
mem[p+4].pts:=ht;
mem[p+2].pts:=dp;
mem[p+5].pts:=0.0;
delta:=desiredwidth-wd;
IF(delta>=0) AND(str>0.0) THEN
mem[p+6].pts:=delta/str
ELSE IF(delta<0) AND(shr>0.0)
THEN mem[p+6].pts:=maximum(-1.0,delta/shr)
ELSE mem[p+6].pts:=0.0;
IF(delta<-shr-0.1) AND(shr>=0.0)
THEN
IF(eqtb[1408].int<>4194784)
THEN
BEGIN
IF odd(eqtb[1408].twohalves.rhword
DIV 2)
THEN BEGIN
println(270);
printreal(-delta-shr);
print(271);
tracedump(p);
println(-1);
END
END
ELSE BEGIN
println(270);
printreal(-delta-shr);
print(271);
tracedump(p);
println(-1);
END;
IF(mem[p+6].pts=0) AND(delta<>0)
THEN mem[p+6].pts:=(0.000001*0.000001*0.00000001);
hpackage:=p;
END;
FUNCTION vpackage(head: integer;
desiredheight: real;
page,xpand: boolean): integer;
LABEL 21, 22, 10;
VAR q: integer;
r: real;
prevp,p: integer;
ht,dp,wd: real;
savedp,topdp,botdp: real;
delta: real;
f,c: integer;
curbot: integer;
curtop: integer;
savep: integer;
separator: integer;
BEGIN
curbot:=25003;
mem[25003].twohalves.lhword:=0;
curtop:=25009;
mem[25009].twohalves.lhword:=0;
separator:=0;
prevp:=head;
p:=mem[head].twohalves.lhword;
ht:=0.0;
dp:=0.0;
wd:=0.0;
str:=0.0;
shr:=0.0;
topdp:=0.0;
botdp:=0.0;
21:
savep:=0;
22:
WHILE p<>0 DO
BEGIN
IF(p>25000) THEN BEGIN
WITH mem[p].twohalves
DO BEGIN f:=byte2;
c:=byte3;
END;
WITH fontinfo[f,c] DO
BEGIN
r:=fmem[wdbase[f]+byte0].pts;
IF r>wd THEN wd:=r;
ht:=ht+dp+fmem[htbase[f]+(byte1
DIV 16)].pts;
dp:=fmem[dpbase[f]+(byte1 MOD
16)].pts
END
END
ELSE CASE mem[p].twohalves.byte2
OF
0, 1, 2, 13:
BEGIN
ht:=ht+dp+mem[p+4].pts;
dp:=mem[p+2].pts;
IF mem[p].twohalves.byte2<>2 THEN
r:=mem[p+3].pts+mem[p+5].pts
ELSE r:=mem[p+3].pts;
IF r>wd THEN wd:=r
END;
3: vpackext(p);
4: BEGIN
q:=mem[p+1].twohalves.lhword;
ht:=ht+dp+mem[q+1].pts;
dp:=0.0;
str:=str+mem[q+2].pts;
shr:=shr+mem[q+3].pts
END;
5, 8, 10:;
11: BEGIN IF botmark<>0 THEN delrclink(botmark);
botmark:=mem[p+1].twohalves.lhword;
mem[botmark].twohalves.rhword:=mem[botmark].twohalves.rhword+1;
IF firstmark<0 THEN
BEGIN firstmark:=botmark;
mem[botmark].twohalves.rhword:=mem[botmark].twohalves.rhword+1
END
END;
12: BEGIN
q:=mem[p+1].twohalves.lhword;
IF savep<>0 THEN confusion;
mem[prevp].twohalves.lhword:=mem[p].twohalves.lhword;
freenode(p,2);
IF mem[q].twohalves.byte3=0 THEN BEGIN
savedp:=dp;
dp:=topdp;
savep:=-prevp;
prevp:=curbot
END
ELSE BEGIN
IF mem[q].twohalves.byte2=2 THEN BEGIN
separator:=q;
p:=mem[prevp].twohalves.lhword;
GOTO 10;
END;
savedp:=dp;
dp:=topdp;
savep:=prevp;
prevp:=curtop
END;
p:=mem[q].twohalves.lhword;
mem[prevp].twohalves.lhword:=p;
freenode(q,5);
GOTO 10
END;
OTHERS:
confusion
END;
prevp:=p;
p:=mem[p].twohalves.lhword;
10:
END;
IF(savep<>0)
THEN
BEGIN
IF savep>0 THEN
BEGIN curtop:=prevp;
topdp:=dp;
END
ELSE BEGIN
curbot:=prevp;
botdp:=dp;
END;
dp:=savedp;
prevp:=abs(savep);
p:=mem[prevp].twohalves.lhword;
GOTO 21
END;
IF separator<>0 THEN BEGIN
savedp:=dp;
dp:=topdp;
savep:=prevp;
prevp:=curtop;
p:=mem[separator].twohalves.lhword;
mem[prevp].twohalves.lhword:=p;
freenode(separator,5);
separator:=0;
GOTO 22;
END;
IF mem[25003].twohalves.lhword<>0 THEN
BEGIN mem[prevp].twohalves.lhword:=mem[25003].twohalves.lhword;
ht:=ht+dp;
dp:=botdp;
END;
IF mem[25009].twohalves.lhword<>0 THEN
BEGIN
IF mem[head].twohalves.lhword<>0 THEN
BEGIN mem[curtop].twohalves.lhword:=mem[head].twohalves.lhword;
ht:=ht+topdp;
END
ELSE dp:=topdp;
mem[head].twohalves.lhword:=mem[25009].twohalves.lhword;
END;
IF page AND(dp>pagemaxdepth)
THEN
BEGIN ht:=ht+dp-pagemaxdepth;
dp:=pagemaxdepth;
END;
p:=getnode(7);
mem[p].twohalves.byte2:=1;
mem[p+1].twohalves.lhword:=mem[head].twohalves.lhword;
IF xpand THEN desiredheight:=ht+desiredheight;
mem[p+4].pts:=desiredheight;
mem[p+3].pts:=wd;
mem[p+2].pts:=dp;
mem[p+5].pts:=0.0;
delta:=desiredheight-ht;
IF(delta>=0) AND(str>0.0) THEN
mem[p+6].pts:= delta/str
ELSE IF(delta<0) AND(shr>0.0)
THEN mem[p+6].pts:=maximum(-1.0,delta/shr)
ELSE mem[p+6].pts:=0.0;
IF(delta<-shr-0.1) AND(shr>=0.0)
THEN
IF(eqtb[1408].int<>4194784)
THEN
BEGIN
IF odd(eqtb[1408].twohalves.rhword
DIV 2)
THEN BEGIN
println(272);
printreal(-delta-shr);
print(273);
tracedump(p);
println(-1);
END
END
ELSE BEGIN
println(272);
printreal(-delta-shr);
print(273);
tracedump(p);
println(-1);
END;
IF(mem[p+6].pts=0) AND(delta<>0)
THEN mem[p+6].pts:=(0.000001*0.000001*0.00000001);
vpackage:=p;
END;
FUNCTION hpack(p: integer;
dw: real;
xpand: boolean): integer;
BEGIN
mem[25004].twohalves.lhword:=p;
hpack:=hpackage(25004,dw,xpand);
dsnodelist(mem[25009].twohalves.lhword);
END;
FUNCTION vpack(p: integer;
dh: real;
xpand: boolean): integer;
BEGIN
mem[25004].twohalves.lhword:=p;
vpack:=vpackage(25004,dh,false,xpand);
END;
PROCEDURE initsftable(periodspacing,queryspacing,exclspacing,
colonspacing,semispacing,commaspacing: real);
VAR j: integer;
BEGIN
FOR j:=0 TO 127 DO sftable[j]:=1.0;
sftable[41]:=0.0;
sftable[39]:=0.0;
sftable[34]:=0.0;
sftable[93]:=0.0;
sftable[46]:=periodspacing;
sftable[63]:=queryspacing;
sftable[33]:=exclspacing;
sftable[58]:=colonspacing;
sftable[59]:=semispacing;
sftable[44]:=commaspacing
END;
FUNCTION interlineglue(delta:
real;
p: integer): integer;
VAR q: integer;
BEGIN
IF delta>=pagemem[7] THEN
BEGIN
q:=getnode(4);
mem[q].twohalves.rhword:=0;
mem[q+1].pts:=delta;
mem[q+2].pts:=mem[p+2].pts;
mem[q+3].pts:=mem[p+3].pts;
END
ELSE
BEGIN
q:=eqtb[1].fourbytes.rhword;
mem[q].twohalves.rhword:=mem[q].twohalves.rhword+1
END;
interlineglue:=q
END;
PROCEDURE append(b: integer);
VAR p,q: integer;
BEGIN
IF(abs(mode)=1) THEN
BEGIN
IF(aux.pts<>
-(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0)) THEN
BEGIN
p:=eqtb[2].fourbytes.rhword;
q:=interlineglue(mem[p+1].pts-aux.pts-mem[b+4].pts,p);
p:=getnode(2);
mem[p].twohalves.byte2:=4;
mem[p+1].twohalves.lhword:=q;
mem[curnode].twohalves.lhword:=p;
mem[p].twohalves.lhword:=b
END
ELSE mem[curnode].twohalves.lhword:=b
END
ELSE mem[curnode].twohalves.lhword:=b;
curnode:=b;
IF abs(mode)=84 THEN aux.pts:=1.0
ELSE aux.pts:=mem[b+2].pts;
END;
PROCEDURE finishdisplay(p: integer);
LABEL 50;
VAR b: integer;
w: real;
dw: real;
nw: real;
lmar: real;
shift: real;
qd: real;
q1,q2: integer;
q: integer;
BEGIN
IF p=0 THEN GOTO 50;
b:=hpack(p,0,true);
w:=mem[b+3].pts;
dw:=pagemem[0];
lmar:=0.0;
IF((hangbegin<=1) AND(hangfirst=0))
OR((hangbegin>1) AND(hangfirst<>0))
THEN BEGIN
IF(hangwidth>=0) THEN lmar:=hangwidth;
dw:=dw-abs(hangwidth)
END;
IF eqnobox<>0 THEN BEGIN nw:=mem[eqnobox+3].pts;
qd:=fmem[parbase[eqtb[2+1393].int]+5].pts+nw
END
ELSE BEGIN nw:=0.0;
qd:=0.0 END;
IF w+qd>dw THEN IF(w-shr)+qd<=dw
THEN BEGIN freenode(b,7);
b:=hpack(p,dw-qd,false);
w:=mem[b+3].pts;
END
ELSE BEGIN
nw:=0.0;
IF w>dw THEN
BEGIN freenode(b,7);
b:=hpack(p,dw,false);
w:=mem[b+3].pts
END
END;
shift:=(dw-w)/2.0;
IF(nw>0) AND(shift<2.0*nw) THEN
BEGIN
IF(NOT(mem[b+1].twohalves.lhword>25000)) AND
(mem[mem[b+1].twohalves.lhword].twohalves.byte2=4) THEN
shift:=0.0
ELSE shift:=(dw-nw-w)/2.0;
END;
IF(shift+lmar<=abovedspwidth)
OR(leqno AND(eqnobox<>0)) THEN
BEGIN q1:=eqtb[4].fourbytes
.rhword;
q2:=q1;
END
ELSE BEGIN q1:=eqtb[8].fourbytes.rhword;
q2:=eqtb[9].fourbytes.rhword;
hangbegin:=hangbegin+1
END;
IF(eqnobox<>0) AND(nw=0.0) AND
leqno THEN
BEGIN
mem[eqnobox+5].pts:=lmar;
BEGIN
mem[curnode].twohalves.lhword:=eqnobox;
curnode:=eqnobox;
END;
q:=getnode(2);
mem[q].twohalves.byte2:=8;
mem[q+1].int:=32767;
BEGIN
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END
END
ELSE BEGIN
q:=getnode(2);
mem[q].twohalves.byte2:=4;
mem[q+1].twohalves.lhword:=q1;
mem[q1].twohalves.rhword:=mem[q1].twohalves.rhword+1;
BEGIN
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END
END;
IF nw>0 THEN BEGIN
q:=getnode(2);
mem[q].twohalves.byte2:=4;
mem[q+1].twohalves.lhword:=0;
IF leqno THEN
BEGIN mem[q].twohalves.lhword:=b;
eqtb[eqnobox].fourbytes.rhword:=q;
b:=hpack(eqnobox,dw-shift,false);
END
ELSE BEGIN mem[q].twohalves.lhword:=eqnobox;
mem[b].twohalves.lhword:=q;
b:=hpack(b,dw-shift,false) END
END;
mem[b+5].pts:=shift+lmar;
append(b);
IF(eqnobox<>0) AND(nw=0.0) AND
(NOT leqno) THEN
BEGIN
mem[eqnobox+5].pts:=lmar+dw-mem[eqnobox+3].pts;
q:=getnode(2);
mem[q].twohalves.byte2:=8;
mem[q+1].int:=32767;
BEGIN
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END;
append(eqnobox)
END
ELSE BEGIN
IF dpenalty<>0 THEN
BEGIN
q:=getnode(2);
mem[q].twohalves.byte2:=8;
mem[q+1].int:=dpenalty;
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END;
q:=getnode(2);
mem[q].twohalves.byte2:=4;
mem[q+1].twohalves.lhword:=q2;
BEGIN
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END;
mem[q2].twohalves.rhword:=mem[q2].twohalves.rhword+1
END;
hangbegin:=hangbegin-3;
50:
END;
PROCEDURE hyphenate(p,n:integer; dhyphen:memoryword);
LABEL 0,1,
2,3,4,5,6,7,
8,10,11,
12,13,14,9,15,16,17,
18;
VAR hyphenationword: ARRAY[0..30]
OF 0..31;
finale:integer;
i,j,q:integer;
truncword: ARRAY[0..30] OF 0..31;
sword:exception;
hash,h:integer;
pc:integer;
firsttime:boolean;
tsuf:suffixtp;
tpref:prefixtp;
b,c:0..31;
r,t:integer;
FUNCTION lexicalorder(word1,word2:
exception): boolean;
LABEL 0;
VAR i:integer;
BEGIN
lexicalorder:=false;
i:=1;
WHILE(word1[i]<>0) DO
BEGIN
IF(word1[i]>word2[i]) THEN GOTO
0;
i:=i+1;
END;
lexicalorder:=true;
0:
END;
BEGIN
q:=p;
FOR i:=1 TO n DO
BEGIN
IF NOT(q>25000) THEN
IF mem[q].twohalves.byte2=6 THEN q:=mem[q].twohalves.lhword
ELSE confusion;
hyphenationword[i]:=mem[q].twohalves.byte3 MOD 32;
q:=mem[q].twohalves.lhword
END;
hyphenationword[0]:=0;
FOR i:=(n+1) TO 30 DO hyphenationword[i]:=0;
finale:=50000;
j:=7;
IF(n<7) THEN j:=n;
0:
FOR i:=0 TO j DO truncword[i]:=hyphenationword[i];
FOR i:=j+1 TO n DO truncword[i]:=0;
FOR i:=1 TO 12 DO sword[i]:=truncword[i];
hash:=0;
FOR i:=1 TO 7 DO hash:=hash*16+truncword[i];
h:=hash MOD 373;
1:
WHILE NOT(lexicalorder(exceptable[h],sword))
DO h:=h-1;
IF(NOT(lexicalorder(sword,exceptable[h])))
THEN
BEGIN
IF(h>0)
THEN
BEGIN
IF((j<>n) OR(truncword[j]<>19))
THEN
GOTO 2;
j:=j-1;
GOTO 0;
END;
h:=372;
GOTO 1
END;
FOR i:=1 TO 16 DO
IF(i IN excephyph[h]) THEN hyphenationword[i]:=0;
GOTO 18;
2:
i:=n-1;
firsttime:=true;
3:
pc:=hyphenationword[i+1];
IF(pc=5) THEN finale:=i+1
ELSE IF(finale=49999) THEN finale:=i+2
ELSE finale:=50000;
4:
tsuf:=suffix[pc];
CASE tsuf.code
OF
0: IF(hyphenationword[i]<>tsuf.oprand)
THEN GOTO 5
ELSE i:=i-1;
1: IF(hyphenationword[i]<>hyphenationword[i-1])
THEN GOTO 5
ELSE i:=i-1;
2: IF(NOT(hyphenationword[i]
IN suffix[tsuf.oprand].alphaset))
THEN GOTO 5
ELSE i:=i-1;
3: IF(i<=tsuf.oprand)
THEN GOTO 5;
4:BEGIN
hyphenationword[i+tsuf.oprand+1]:=0;
GOTO 8
END;
5: GOTO 8;
6: BEGIN i:=i+tsuf.oprand-1;
GOTO 6
END;
7: IF firsttime THEN BEGIN i:=n-2;
GOTO 7 END;
8: BEGIN
j:=tsuf.oprand;
IF((j<>0) OR firsttime) THEN
hyphenationword[i+j+1]:=0
END;
9: BEGIN
IF((hyphenationword[n]=4)
AND(hyphenationword[n-1]=5))
THEN BEGIN i:=n-3;
finale:=49999;
GOTO 6 END
ELSE GOTO 8
END;
OTHERS:
confusion
END;
pc:=tsuf.truex;
GOTO 4;
5:
pc:=tsuf.falsex;
GOTO 4;
6:
hyphenationword[i+2]:=0;
7:
firsttime:=false;
IF i>3 THEN GOTO 3;
8:
pc:=hyphenationword[1];
i:=2;
10:
j:=i-1;
11:
tpref:=prefix[pc];
CASE tpref.code
OF
0: IF(hyphenationword[i]=tpref.oprand)
THEN
BEGIN i:=i+1;
pc:=tpref.truex;
GOTO 11
END
ELSE BEGIN pc:=tpref.falsex;
GOTO 11
END;
6: BEGIN i:=i-tpref.oprand+1;
IF(hyphenationword[i]=0) THEN
GOTO 18;
pc:=hyphenationword[i-1];
hyphenationword[i-1]:=0;
GOTO 10
END;
8: BEGIN
IF(tpref.oprand<>0) THEN
hyphenationword[i-tpref.oprand]:=0;
GOTO 12
END;
2: IF(hyphenationword[i] IN tpref.alphaset)
THEN GOTO 12
ELSE BEGIN i:=j;
GOTO 14 END;
5: GOTO 18;
4: GOTO 15;
7: GOTO 13;
OTHERS:
END;
12:
IF(hyphenationword[i+1]=0)
THEN GOTO 18;
IF((hyphenationword[i+1]=5) AND
(hyphenationword[i+2]=4)
AND(hyphenationword[i+3]=0))
THEN
GOTO 18;
c:=hyphenationword[i];
hyphenationword[i]:=0;
GOTO 14;
13:
c:=hyphenationword[i];
14:
i:=i+1;
IF NOT( c IN suffix[0].alphaset)
THEN GOTO 13;
9:
IF(c=0)
THEN GOTO 18;
15:
b:=hyphenationword[i];
i:=i+1;
IF( b IN suffix[0].alphaset)
THEN
BEGIN c:=b;
GOTO 9
END;
16:
c:=hyphenationword[i];
IF((b=17) AND(c=21)) THEN BEGIN
i:=i-1;
GOTO 12 END;
IF( c IN suffix[0].alphaset)
THEN
BEGIN i:=i+1;
GOTO 9
END;
IF(b=c)
THEN IF((c<>12) AND(c<>19))
THEN GOTO 12
ELSE BEGIN c:=hyphenationword[i+1];
IF(c=0) THEN GOTO 18;
IF(( c IN suffix[0].alphaset)) THEN GOTO 17;
i:=i+2;
GOTO 13;
END
ELSE BEGIN
j:=btable[b].hchar;
IF((c=8) AND(j<>0))
THEN
BEGIN
b:=b+j-2;
i:=i+1;
GOTO 16 END
ELSE IF((c=11) AND(b=3))
THEN
BEGIN i:=i+1;
GOTO 12
END;
j:=btable[c].hchar;
IF((hyphenationword[i+1]=8) AND (j<>0)) THEN
BEGIN c:=c+j-2;
j:=i+2
END
ELSE j:=i+1;
IF hyphenationword[j]=0 THEN GOTO
18;
IF(( hyphenationword[j] IN suffix[0].alphaset)) THEN BEGIN
IF NOT(c IN btable[b].alphaset)
THEN GOTO 12;
IF(NOT(c IN btable[btable[b].weak+26].alphaset))
THEN BEGIN i:=j+1;
GOTO 15
END;
i:=j-1;
IF((((hyphenationword[i+1]=1)
AND(hyphenationword[i+2]=7)
AND(finale=i+3))
OR((hyphenationword[i+1]=5)
AND(hyphenationword[i+2]=19)
AND(hyphenationword[i+3]=20)))
AND(hyphenationword[i+4]=0))
THEN GOTO 18
ELSE GOTO 17
END;
i:=j+1;
GOTO 13 END;
17:
IF((hyphenationword[i+1]=5)
AND(hyphenationword[i+2]=18)
AND(hyphenationword[i+3]=0))
THEN GOTO 18
ELSE GOTO 12;
18:
q:=mem[p].twohalves.lhword;
FOR i:=3 TO n-2 DO
BEGIN
IF(NOT(q>25000)) AND(mem[q].twohalves
.byte2=6) THEN q:=mem[q].twohalves.lhword;
IF((hyphenationword[i]<>0) OR
((i+2>=finale) AND(i<=finale)))
THEN q:=mem[q].twohalves.lhword
ELSE BEGIN
t:=mem[q].twohalves.lhword;
r:=getnode(2);
mem[r].twohalves.byte2:=9;
mem[r].twohalves.byte3:=2;
mem[r+1]:=dhyphen;
mem[q].twohalves.lhword:=r;
mem[r].twohalves.lhword:=t;
q:=t
END
END
END;
PROCEDURE justification(initwidth: real; linechange: integer;
hangfirst: integer; hangwidth: real; penlt: boolean);
LABEL 9,
7, 6, 5;
VAR secondpass: boolean;
threshold: real;
ll: integer;
bestbet: integer;
q: integer;
firstwidth, secondwidth: real;
firstindent, secondindent: real;
easyline: integer;
notwarned: boolean;
p: integer;
prevp,n: integer;
t: integer;
qq: integer;
fntnum: integer;
c: integer;
dh: memoryword;
s: integer;
lowbad: real;
l,d: integer;
r: integer;
g: integer;
pen: integer;
PROCEDURE trybreak(penalt,w: real; hyph: integer);
LABEL 7, 8, 0;
VAR
l: integer;
oldl: integer;
r,prevr: integer;
setting: integer;
badness: real;
lwidth: real;
nobreakyet: boolean;
newwidth,newstretch,newshrink:
real;
q: integer;
s,ss: integer;
glue: real;
t: real;
BEGIN(* IF EQTB[1426].INT<>0 THEN
BEGIN PRINTLN(-1);
FOR S:=1 TO DIAGPTR DO PRINT(DIAGNOSE[S]);
PRINT(58);
END;
DIAGPTR:=0;*);
nobreakyet:=true;
prevr:=25010;
oldl:=0;
lwidth:=0.0;
WHILE true DO
BEGIN
8:
r:=mem[prevr].int;
WITH mem[r+5].twohalves DO l:=lhword;
IF(r=0) OR(l>oldl) THEN
BEGIN
IF leastbadness<
(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0) THEN
BEGIN
FOR setting:=0 TO 3 DO
IF lowestbadness[setting]<
(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0) THEN
BEGIN
IF lowestbadness[setting]<=leastbadness+eqtb[1421].int/10000 THEN
BEGIN
IF nobreakyet THEN BEGIN
newwidth:=curwd;
newstretch:=curst;
newshrink:=cursh;
s:=p;
WHILE s<>0 DO
BEGIN
IF(s>25000) THEN GOTO 0
ELSE CASE mem[s].twohalves.byte2
OF
4: BEGIN ss:=mem[s+1].twohalves.lhword;
newwidth:=newwidth+mem[ss+1].pts;
newstretch:=newstretch+mem[ss+2].pts;
newshrink:=newshrink+mem[ss+3].pts
END;
5, 8,9:;
6: newwidth:=newwidth+mem[s+1].pts;
10: IF s<>p THEN GOTO 0;
OTHERS:
GOTO 0
END;
s:=mem[s].twohalves.lhword;
END;
0:
nobreakyet:=false;
END;
q:=getnode(8);
mem[q+4].twohalves.lhword:=bestplace[setting];
mem[q+6].twohalves.rhword:=p;
mem[q+1].pts:=newwidth;
mem[q+2].pts:=newstretch;
mem[q+3].pts:=newshrink;
WITH mem[q+5].twohalves DO BEGIN
lhword:=bestline[setting]+1;
byte3:=hyph;
byte2:=setting END;
mem[q+7].pts:=lowestbadness[setting];
(* IF EQTB[1426].INT<>0
THEN BEGIN PRINTLN(276);
PRINTINT(Q);
PRINT(277);
PRINTINT(MEM[Q+4].TWOHALVES.LHWORD);
PRINT(44);
PRINTINT(BESTLINE[SETTING]);
PRINT(91);
WITH MEM[Q+5].TWOHALVES DO BEGIN
PRINT(278);
PRINTINT(LHWORD);
PRINT(279);
PRINTINT(SETTING);
PRINT(280);
PRINTINT(HYPH);
END;
PRINT(281);
PRINTREAL(MEM[Q+7].PTS);
END;*);
mem[q].int:=r;
mem[prevr].int:=q;
prevr:=q;
END;
lowestbadness[setting]:=
(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0);
END;
leastbadness:=
(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0);
END;
IF r=0 THEN GOTO 7;
IF l<easyline THEN oldl:=l
ELSE
oldl:=50000;
IF parshape<>0 THEN
lwidth:=mem[parshape+2*minimum(mem[parshape].int,l)].pts
ELSE IF l>linechange THEN lwidth:=secondwidth
ELSE lwidth:=firstwidth;
END;
t:=mem[r+1].pts+lwidth;
IF w>t THEN
BEGIN glue:=cursh-mem[r+3].pts;
IF glue<0.0001 THEN glue:=0.0001;
IF(w-glue)>t THEN
badness:=
(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0)
ELSE BEGIN glue:=(w-t)/glue;
badness:=glue*glue*glue;
IF glue>=0.5 THEN setting:=0
ELSE setting:=1;
IF badness>1000000.0 THEN badness:=1000000.0;
END;
END
ELSE BEGIN glue:=curst-mem[r+2].pts;
IF(mem[r+2].pts>1000000.0) AND notwarned THEN
BEGIN
println(282);
error;
notwarned:=false;
END;
IF glue<0.0001 THEN glue:=0.0001;
glue:=(t-w)/glue;
badness:=glue*glue*glue;
IF glue<0.5 THEN setting:=1
ELSE IF glue<1.0 THEN setting:=2
ELSE setting:=3;
IF badness>1000000.0 THEN badness:=1000000.0;
END;
(* IF EQTB[1426].INT>3 THEN
BEGIN PRINTLN(274);
PRINTINT(R);
PRINT(275);
PRINTREAL(BADNESS);
END;*);
IF(badness=
(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0)) OR
(penalt=
-(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0)) THEN
BEGIN
mem[prevr]:=mem[r];
mem[r]:=mem[25011];
mem[25011].int:=r;
IF secondpass AND(mem[25010].int=0) AND
(leastbadness=
(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0)) THEN
BEGIN
badness:=1000000.0;
setting:=0;
END
ELSE IF badness>threshold THEN GOTO 8;
END
ELSE BEGIN prevr:=r;
IF badness>threshold THEN GOTO 8;
END;
IF penalt>=0 THEN
badness:=(badness+penalt+0.01)*(badness+penalt+0.01)
ELSE IF penalt>
-(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0) THEN
badness:=(badness+0.01)*(badness+0.01)-penalt*penalt
ELSE badness:=(badness+0.01)*(badness+0.01);
IF(hyph<>0) AND(mem[r+5].twohalves.byte3<>0) THEN
badness:=badness+eqtb[1411].int/10000;
IF abs(mem[r+5].twohalves.byte2-setting)>1 THEN
badness:=badness+eqtb[1421].int/10000;
badness:=badness+mem[r+7].pts;
IF badness<lowestbadness[setting] THEN
BEGIN bestplace[setting]:=r;
bestline[setting]:=l;
lowestbadness[setting]:=badness;
IF badness<leastbadness THEN leastbadness:=badness;
END;
END;
7:
END;
BEGIN(* DIAGPTR:=0;*);
lines:=0;
lastwidth:=0.0;
notwarned:=true;
lowestbadness[0]:=
(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0);
lowestbadness[1]:=
(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0);
lowestbadness[2]:=
(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0);
lowestbadness[3]:=
(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0);
leastbadness:=
(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0);
IF parshape<>0 THEN easyline:=mem[parshape].int
ELSE BEGIN
IF linechange<32767 THEN easyline:=linechange+1
ELSE easyline:=1;
IF hangfirst=0 THEN
BEGIN firstindent:=0;
secondindent:=maximum(hangwidth,0.0);
firstwidth:=initwidth;
secondwidth:=initwidth-abs(hangwidth);
END
ELSE BEGIN secondindent:=0;
firstindent:=maximum(hangwidth,0.0);
secondwidth:=initwidth;
firstwidth:=initwidth-abs(hangwidth);
END
END;
IF eqtb[1422].int<>0 THEN easyline:=32767
;
secondpass:=false;
threshold:=eqtb[1423].int;
WHILE true DO BEGIN
q:=getnode(8);
mem[q].int:=0;
mem[q+4].twohalves.lhword:=0;
mem[q+6].twohalves.rhword:=25003;
mem[q+1].pts:=0.0;
mem[q+2].pts:=0.0;
mem[q+3].pts:=0.0;
mem[q+7].pts:=0.0;
WITH mem[q+5].twohalves DO BEGIN
lhword:=1;
byte3:=0;
byte2:=1 END;
mem[25010].int:=q;
mem[25011].int:=0;
p:=mem[25003].twohalves.lhword;
curwd:=0.0;
curst:=0.0;
cursh:=0.0;
autobreaking:=true;
prevp:=p;
WHILE(p<>0) AND(mem[25010].int
<>0) DO
BEGIN
IF(p>25000) THEN
WITH mem[p].twohalves
DO
BEGIN
curwd:=curwd+charwd(byte2,byte3);(* IF EQTB[1426].INT<>0
THEN
BEGIN
DIAGPTR:=DIAGPTR+1;
DIAGNOSE[DIAGPTR]:=BYTE3;
DIAGPTR:=DIAGPTR+1;
DIAGNOSE[DIAGPTR]:=64;
DIAGPTR:=DIAGPTR+1;
IF BYTE2<=58 THEN DIAGNOSE[DIAGPTR]:=BYTE2
+64 ELSE DIAGNOSE[DIAGPTR]:=BYTE2;
DIAGPTR:=DIAGPTR+1;
DIAGNOSE[DIAGPTR]:=32;
END;*);
END
ELSE CASE mem[p].twohalves.byte2
OF
0, 1, 2: curwd:=curwd+mem[p+3].pts;
3: justext(p);
4, 5:
BEGIN
IF autobreaking THEN
BEGIN
IF(prevp>25000) THEN trybreak(0.0,curwd,0)
ELSE CASE mem[prevp].twohalves
.byte2
OF
0,1,7,9,11,12:
trybreak(0.0,curwd,0);
OTHERS:
END;
END;
IF mem[p].twohalves.byte2=4 THEN
BEGIN
t:=mem[p+1].twohalves.lhword;
curwd:=curwd+mem[t+1].pts;
curst:=curst+mem[t+2].pts;
cursh:=cursh+mem[t+3].pts;
IF secondpass AND autobreaking
THEN
BEGIN
qq:=mem[p].twohalves.lhword;
IF(qq>25000) THEN
BEGIN
n:=0;
fntnum:=mem[qq].twohalves.byte2;
WHILE qq<>0 DO BEGIN IF
(qq>25000) THEN
WITH mem[qq].twohalves
DO
IF byte2=fntnum THEN
BEGIN c:=byte3;
IF c>122 THEN GOTO 7
ELSE IF c<97 THEN
BEGIN
IF eqtb[1424].int<>0 THEN c:=c+32;
IF(c<97) OR(c>122) THEN GOTO
7
END;
n:=n+1
END
ELSE GOTO 7
ELSE IF mem[qq].twohalves.byte2=6 THEN
ELSE GOTO 7;
qq:=mem[qq].twohalves.lhword;
END;
7:
IF(n<5) OR(qq=0) THEN GOTO
6;
IF(qq>25000) THEN
BEGIN
IF sftable[mem[qq].twohalves
.byte3]=1.0 THEN GOTO 6
END
ELSE IF(mem[qq].twohalves.byte2<>4) AND
(mem[qq].twohalves.byte2<>8) THEN GOTO 6;
WITH dh.twohalves
DO BEGIN byte2:=fntnum;
byte3:=45 END;
hyphenate(mem[p].twohalves.lhword,n,dh);
6:
END;
END;
END
END;
11, 12:;
6: BEGIN
IF(NOT(mem[p].twohalves.lhword>25000)) AND
(mem[mem[p].twohalves.lhword].twohalves.byte2=4) AND
autobreaking THEN trybreak(0.0,curwd,0);
curwd:=curwd+mem[p+1].pts;
END;
7: IF mem[p+1].int=0 THEN autobreaking:=false
ELSE autobreaking:=true;
8: BEGIN n:=mem[p+1].int;
IF(n<1000) AND(n<32767) THEN
trybreak(n/100.0,curwd,0)
END;
9: IF mem[p].twohalves.byte3=1 THEN
trybreak(eqtb[1425].int/100,curwd,1)
ELSE WITH mem[p+1].twohalves
DO
trybreak(eqtb[1410].int/100,curwd+charwd(byte2
,byte3),1);
10: BEGIN IF mem[p].twohalves.byte3<2 THEN
trybreak(
-(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0),curwd,0)
END;
OTHERS:
confusion
END;
prevp:=p;
p:=mem[p].twohalves.lhword;
END;
IF p=0 THEN
BEGIN
trybreak(
-(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0),curwd,1);
IF mem[25010].int<>0 THEN BEGIN
q:=mem[25010].int;
lowbad:=(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0);
WHILE q<>0 DO
BEGIN
IF mem[q+7].pts<lowbad
THEN
BEGIN lowbad:=mem[q+7].pts;
bestbet:=q;
END;
q:=mem[q].int;
END;
WITH mem[bestbet+5].twohalves
DO ll:=lhword;
s:=0;
IF eqtb[1422].int<>0 THEN BEGIN
q:=mem[25010].int;
WHILE q<>0 DO
BEGIN
WITH mem[q+5].twohalves DO l:=lhword;
d:=l-ll;
IF((d<s) AND(eqtb[1422].int
<=d)) OR((d>s) AND(eqtb[1422].int
>=d)) THEN
BEGIN bestbet:=q;
s:=d;
lowbad:=mem[q+7].pts;
END
ELSE IF(d=s) AND(mem[q+7].pts
<lowbad) THEN
BEGIN lowbad:=mem[q+7].pts;
bestbet:=q;
END;
q:=mem[q].int;
END;
ll:=ll+s;
END;
IF secondpass OR(s=eqtb[1422].int) THEN GOTO 9;
END;
END;
q:=mem[25011].int;
WHILE q<>0 DO
BEGIN p:=mem[q].int;
freenode(q,8);
q:=p
END;
secondpass:=true;
threshold:=eqtb[1409].pts;
END;
9:
ll:=ll-1;
q:=0;
WHILE bestbet<>0 DO
BEGIN mem[bestbet+7].int:=q;
q:=bestbet;
bestbet:=mem[q+4].twohalves.lhword;
END;
q:=mem[q+7].int;
lines:=0;
WHILE mem[25003].twohalves.lhword<>0 DO
BEGIN
qq:=mem[q+7].int;
r:=mem[q+6].twohalves.rhword;
IF r<>0 THEN
BEGIN
CASE mem[r].twohalves.byte2
OF
4: BEGIN
delgluelink(mem[r+1].twohalves
.lhword);
mem[r+1].twohalves.lhword:=16;
END;
6: mem[r+1].pts:=0.0;
9: IF mem[r].twohalves.byte3<>1 THEN
mem[r].twohalves.byte3:=0;
OTHERS:
END;
t:=mem[r].twohalves.lhword;
mem[r].twohalves.lhword:=0;
END
ELSE t:=0;
WHILE t<>0 DO
BEGIN
IF t=mem[qq+6].twohalves.rhword
THEN GOTO 5;
IF(t>25000) THEN GOTO 5
ELSE BEGIN
r:=mem[t].twohalves.lhword;
CASE mem[t].twohalves.byte2
OF
4: BEGIN delgluelink(mem[t+1].twohalves
.lhword);
freenode(t,2) END;
6:freenode(t,2);
8: freenode(t,2);
9: freenode(t,2);
5: BEGIN dsnodelist(mem[t].twohalves
.lhword);
freenode(t,2) END;
OTHERS:
GOTO 5
END;
END;
t:=r;
END;
5:;
lines:=lines+1;
IF parshape<>0 THEN
BEGIN
n:=parshape+2*minimum(mem[parshape].int
,lines);
curwd:=mem[n].pts;
curst:=mem[n-1].pts;
END
ELSE IF lines<=linechange THEN
BEGIN curwd:=firstwidth;
curst:=firstindent;
END
ELSE BEGIN curwd:=secondwidth;
curst:=secondindent;
END;
r:=hpackage(25003,curwd,false);
IF eqtb[1416].int<>0 THEN mem[r+6].pts
:=mem[r+6].pts*(100.0/(100.0+eqtb[1416].int
));
IF lines=ll THEN
BEGIN g:=eqtb[11].fourbytes.rhword;
lastwidth:=mem[r+3].pts-mem[g+1].pts
+curst;
IF mem[r+6].pts>=0 THEN lastwidth:=lastwidth-mem[r+6].pts
*mem[g+2].pts
ELSE lastwidth:=lastwidth-mem[r+6].pts
*mem[g+3].pts
END;
mem[r+5].pts:=curst;
append(r);
IF mode>0 THEN BEGIN
IF mem[25009].twohalves.lhword<>0 THEN
BEGIN
BEGIN
mem[curnode].twohalves.lhword:=mem[25009].twohalves.lhword;
curnode:=mem[25009].twohalves
.lhword;
END;
WHILE mem[curnode].twohalves.lhword<>0 DO
curnode:=mem[curnode].twohalves.lhword;
END;
IF((lines=1) AND(ll>1)) OR(penlt
AND(lines=ll-1)) THEN pen:=eqtb[1412].int
ELSE pen:=0;
IF(mem[q+5].twohalves.byte3<>0) AND(t<>0) THEN
pen:=pen+eqtb[1413].int;
IF pen<>0 THEN BEGIN
q:=getnode(2);
mem[q].twohalves.byte2:=8;
mem[q+1].int:=pen;
BEGIN
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END
END;
END
ELSE dsnodelist(mem[25009].twohalves.lhword);
mem[25003].twohalves.lhword:=t;
q:=qq;
END;
q:=mem[25010].int;
WHILE q<>0 DO
BEGIN p:=mem[q].int;
freenode(q,8);
q:=p
END;
q:=mem[25011].int;
WHILE q<>0 DO
BEGIN p:=mem[q].int;
freenode(q,8);
q:=p
END;
END;
PROCEDURE finishparagraph(penlt: boolean);
VAR q: integer;
BEGIN
IF(NOT(curnode>25000)) AND
(mem[curnode].twohalves.byte2=4) THEN
BEGIN
delgluelink(mem[curnode+1].twohalves
.lhword);
mem[curnode].twohalves.byte2:=8;
mem[curnode+1].int:=32767;
END
ELSE BEGIN
q:=getnode(2);
mem[q].twohalves.byte2:=8;
mem[q+1].int:=32767;
BEGIN
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END
END;
q:=getnode(2);
mem[q].twohalves.byte2:=4;
mem[q+1].twohalves.lhword:=eqtb[11].fourbytes.rhword;
mem[eqtb[11].fourbytes.rhword].twohalves.rhword:=
mem[eqtb[11].fourbytes.rhword].twohalves.rhword+1;
BEGIN
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END;
mem[25003].twohalves.lhword:=mem[head].twohalves.lhword;
popnest;
justification(pagemem[0],hangbegin,hangfirst,hangwidth,penlt);
END;
FUNCTION finishmlist(p:integer):
integer;
VAR q: integer;
BEGIN
IF(aux.int<>0) AND(aux.pts<>
-(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0)) THEN
BEGIN
WITH mem[aux.int+3].fourbytes DO
BEGIN byte0:=3;
rhword:=mem[head].twohalves.lhword
END;
IF p<>0 THEN BEGIN
WITH mem[aux.int+2].fourbytes
DO
BEGIN q:=rhword;
byte0:=3;
rhword:=mem[q].twohalves.lhword
END;
mem[q].twohalves.lhword:=aux.int;
mem[head].twohalves.lhword:=q END
ELSE mem[head].twohalves.lhword:=aux.int;
curnode:=aux.int
END;
mem[curnode].twohalves.lhword:=p;
IF head<>curnode THEN q:=mem[head].twohalves
.lhword
ELSE q:=0;
popnest;
finishmlist:=q
END;
FUNCTION boxchar(fontkind,charcode,style:integer;
corr:boolean):integer;
VAR q,b:integer;
BEGIN
fount:=eqtb[fontsize[style]+fontkind+1393].int;
q:=getavail;
WITH mem[q].twohalves
DO BEGIN byte2:=fount;
byte3:=charcode END;
b:=getnode(7);
mem[b].twohalves.byte2:=0;
mem[b+1].twohalves.lhword:=q;
WITH fontinfo[fount,charcode]
DO
BEGIN
mem[b+3].pts:=fmem[wdbase[fount]+byte0
].pts;
mem[b+4].pts:=fmem[htbase[fount]+(byte1
DIV 16)].pts;
mem[b+2].pts:=fmem[dpbase[fount]+(byte1
MOD 16)].pts;
IF corr AND(fontkind<>3)
AND((byte2 DIV 4)<>0) THEN
BEGIN mem[b+3].pts:=mem[b+3].pts
+fmem[icbase[fount]+(byte2 DIV
4)].pts;
mem[b+6].pts:=(0.000001*0.000001*0.00000001)
END
ELSE mem[b+6].pts:=0.0;
END;
mem[b+5].pts:=0.0;
boxchar:=b
END;
FUNCTION compactlist(p:integer
):integer;
FORWARD;
FUNCTION compactbox(p:integer):integer;
VAR r: integer;
BEGIN
r:=mem[p+1].twohalves.lhword;
IF r=0 THEN compactbox:=p
ELSE
IF mem[r].twohalves.lhword<>0 THEN
BEGIN mem[p+1].twohalves.lhword:=compactlist(r);
compactbox:=p
END
ELSE IF(r>25000) THEN
IF(mem[p+6].pts=0.0) AND(mem[p+5].pts
=0.0) THEN
BEGIN freenode(p,7);
compactbox:=r
END
ELSE compactbox:=p
ELSE BEGIN
IF(mem[r].twohalves.byte2=0) OR(mem[r].twohalves.byte2=1) THEN
mem[p+1].twohalves.lhword:=compactbox(r);
compactbox:=p
END
END;
FUNCTION compactlist;
VAR q,r,s,nextq:integer;
BEGIN
r:=-1;
q:=p;
WHILE q<>0 DO
BEGIN nextq:=mem[q].twohalves
.lhword;
IF NOT(q>25000) THEN
IF(mem[q].twohalves.byte2=0) OR(mem[q].twohalves.byte2=1) THEN
BEGIN
s:=compactbox(q);
IF s<>q THEN
BEGIN
mem[s].twohalves.lhword:=nextq;
IF r>=0 THEN mem[r].twohalves
.lhword:=s
ELSE p:=s;
q:=s
END
END;
r:=q;
q:=nextq
END;
compactlist:=p
END;
FUNCTION mathglue(x,y,z: real):
integer;
VAR g,p:integer;
m: integer;
BEGIN
g:=getnode(2);
p:=getnode(4);
mem[g].twohalves.byte2:=4;
mem[g+1].twohalves.lhword:=p;
IF curxspace<>0.0 THEN
BEGIN
IF x>0 THEN m:=trunc((x/curxspace)+0.99999)
ELSE m:=trunc(x/curxspace);
mem[p+1].pts:=curxspace*m;
mem[p+2].pts:=0.0;
mem[p+3].pts:=0.0
END
ELSE BEGIN mem[p+1].pts:=x*curquad;
mem[p+2].pts:=y*curquad;
mem[p+3].pts:=z*curquad
END;
mem[p].twohalves.rhword:=0;
mathglue:=g
END;
FUNCTION varsymbol(delimiters:
bytes4;
style: integer;
size: real):integer;
LABEL 4, 5, 50;
VAR b: integer;
ch, fntnum: integer;
scf,scc,lcf,lcc: integer;
j: integer;
top,mid,bot,ext,curnode,t,n: integer;
exth,s,axis:real;
BEGIN
b:=getnode(7);
ch:=-1;
WITH delimiters DO
BEGIN scf:=byte0;
scc:=byte1;
lcf:=byte2;
lcc:=byte3 END;
IF((scf<>0) OR(scc<>0))
THEN
BEGIN ch:=scc;
j:=fontsize[style]+scf;
WHILE j>=0 DO
BEGIN fntnum:=eqtb[j+1393].int;
WITH fontinfo[fntnum,ch] DO
IF(fmem[htbase[fntnum]+(byte1
DIV 16)].pts+fmem[dpbase[fntnum]+(byte1
MOD 16)].pts)>=size
THEN GOTO 5;
j:=j-4 END
END;
IF((lcf=0) AND(lcc=0))
THEN GOTO 5;
IF lcf<>3 THEN
BEGIN println(283);
printoctal(128*lcf+lcc);
print(284);
error;
GOTO 5
END;
fntnum:=eqtb[3+1393].int;
ch:=lcc;
WHILE true DO
WITH fontinfo[fntnum,ch] DO
CASE(byte2 MOD 4)
OF
3: BEGIN j:=byte3;
GOTO 4;
END;
0: GOTO 5;
1:
BEGIN
println(285);
printoctal(128*lcf+lcc);
error;
ch:=-1;
GOTO 5
END;
2:
BEGIN
IF(fmem[htbase[fntnum]+(byte1
DIV 16)].pts+fmem[dpbase[fntnum]+(byte1
MOD 16)].pts)>=size
THEN GOTO 5;
ch:=byte3;
END
END;
4:
WITH fmem[extbase[fntnum]+j].fourbytes
DO BEGIN top:=byte0;
mid:=byte1;
bot:=byte2;
ext:=byte3
END;
s:=0.0;
exth:=chardp(fntnum,ext);
IF top<>0 THEN s:=s+chardp(fntnum,top);
IF mid<>0 THEN s:=s+chardp(fntnum,mid);
IF bot<>0 THEN s:=s+chardp(fntnum,bot);
n:=0;
WHILE s<size DO
BEGIN n:=n+1;
s:=s+exth;
IF mid<>0 THEN s:=s+exth
END
;
curnode:=25004;
IF top<>0 THEN
BEGIN t:=getavail;
WITH mem[t].twohalves
DO BEGIN byte2:=fntnum;
byte3:=top END;
BEGIN
mem[curnode].twohalves.lhword:=t;
curnode:=t;
END
END;
FOR j:=1 TO n DO
BEGIN t:=getavail;
WITH mem[t].twohalves
DO BEGIN byte2:=fntnum;
byte3:=ext END;
BEGIN
mem[curnode].twohalves.lhword:=t;
curnode:=t;
END
END;
IF mid<>0 THEN
BEGIN t:=getavail;
WITH mem[t].twohalves
DO BEGIN byte2:=fntnum;
byte3:=mid END;
BEGIN
mem[curnode].twohalves.lhword:=t;
curnode:=t;
END;
FOR j:=1 TO n DO
BEGIN t:=getavail;
WITH mem[t].twohalves
DO BEGIN byte2:=fntnum;
byte3:=ext END;
BEGIN
mem[curnode].twohalves.lhword:=t;
curnode:=t;
END;
END;
END;
IF bot<>0 THEN
BEGIN t:=getavail;
WITH mem[t].twohalves
DO BEGIN byte2:=fntnum;
byte3:=bot END;
BEGIN
mem[curnode].twohalves.lhword:=t;
curnode:=t;
END
END;
mem[curnode].twohalves.lhword:=0;
mem[b].twohalves.byte2:=1;
mem[b+1].twohalves.lhword:=mem[25004].twohalves.lhword;
axis:=fmem[parbase[eqtb[fontsize[style]+2+1393].int
]+21].pts;
mem[b+4].pts:=s/2+axis;
mem[b+2].pts:=s/2-axis;
mem[b+3].pts:=charwd(fntnum,ext);
mem[b+6].pts:=0.0;
mem[b+5].pts:=0.0;
GOTO 50;
5:
IF ch<0 THEN BEGIN mem[b].twohalves
.byte2:=0;
mem[b+1].twohalves.lhword:=0;
mem[b+3].pts:=
fmem[parbase[eqtb[fontsize[style]+2+1393].int]+5].pts/9.0;
mem[b+4].pts:=0.0;
mem[b+2].pts:=0.0;
mem[b+5].pts:=0.0;
mem[b+6].pts:=(0.000001*0.000001*0.00000001)
END
ELSE BEGIN t:=getavail;
WITH mem[t].twohalves
DO BEGIN byte2:=fntnum;
byte3:=ch END;
mem[b].twohalves.byte2:=0;
mem[b+1].twohalves.lhword:=t;
WITH fontinfo[fntnum,ch] DO
BEGIN
mem[b+3].pts:=fmem[wdbase[fntnum]+byte0
].pts;
mem[b+4].pts:=fmem[htbase[fntnum]+(byte1
DIV 16)].pts;
mem[b+2].pts:=fmem[dpbase[fntnum]+(byte1
MOD 16)].pts;
END;
mem[b+6].pts:=0.0;
mem[b+5].pts:=0.0
END;
50:
varsymbol:=b
END;
FUNCTION fractionrule(targetthickness:
real):integer;
VAR p:integer;
BEGIN p:=getnode(5);
mem[p].twohalves.byte2:=2;
mem[p+4].pts:=targetthickness;
mem[p+2].pts:=0.0;
mem[p+3].pts:=-100000.0;
fractionrule:=p
END;
FUNCTION overbar(p:integer;
desiredheight,targetthickness,clr:real):integer;
VAR b,q,r: integer;
BEGIN
b:=getnode(7);
mem[b].twohalves.byte2:=0;
mem[b+4].pts:=clr;
mem[b+3].pts:=0.0;
mem[b+2].pts:=0.0;
mem[b+6].pts:=0.0;
mem[b+5].pts:=0.0;
q:=fractionrule(targetthickness);
r:=getnode(2);
mem[r].twohalves.byte2:=4;
mem[r+1].twohalves.lhword:=0;
mem[b].twohalves.lhword:=q;
mem[q].twohalves.lhword:=r;
mem[r].twohalves.lhword:=p;
overbar:=vpack(b,desiredheight+clr,false)
END;
FUNCTION rebox(p: integer;
desiredwidth,offset: real): integer;
VAR b,q1,q2,q3,l,q:integer;
delta,str,shr:real;
BEGIN
delta:=desiredwidth-mem[p+3].pts;
q1:=getnode(2);
mem[q1].twohalves.byte2:=4;
mem[q1+1].twohalves.lhword:=12;
q3:=getnode(7);
mem[q3].twohalves.byte2:=0;
mem[q3+3].pts:=offset;
mem[q3+4].pts:=0.0;
mem[q3+2].pts:=0.0;
mem[q3+5].pts:=0.0;
mem[q3+6].pts:=0.0;
mem[q1].twohalves.lhword:=q3;
q2:=getnode(2);
mem[q2].twohalves.byte2:=4;
mem[q2+1].twohalves.lhword:=12;
IF(mem[p].twohalves.byte2=0) AND(mem[p+6].pts=0.0)
THEN
BEGIN
str:=2*mem[12+2].pts;
shr:=2*mem[12+3].pts;
b:=mem[p+1].twohalves.lhword;
mem[p+1].twohalves.lhword:=q1;
IF b<>0 THEN BEGIN mem[q3].twohalves
.lhword:=b;
WHILE b<>0 DO
BEGIN
IF mem[b].twohalves.byte2=4 THEN
BEGIN q:=mem[b+1].twohalves.lhword;
str:=str+mem[q+2].pts;
shr:=shr+mem[q+3].pts
END;
l:=b;
b:=mem[b].twohalves.lhword
END;
mem[l].twohalves.lhword:=q2 END
ELSE mem[q3].twohalves.lhword:=q2;
IF delta>=0 THEN
BEGIN
IF str>0 THEN mem[p+6].pts
:=delta/str
END
ELSE IF shr>0 THEN mem[p+6].pts
:=delta/shr
ELSE mem[p+6].pts:=(0.000001*0.000001*0.00000001)
;
mem[p+3].pts:=desiredwidth+offset;
rebox:=p
END
ELSE BEGIN
b:=getnode(7);
mem[b].twohalves.byte2:=0;
mem[b+1].twohalves.lhword:=q1;
mem[q3].twohalves.lhword:=p;
mem[p].twohalves.lhword:=q2;
mem[b+4].pts:=mem[p+4].pts;
mem[b+2].pts:=mem[p+2].pts;
mem[b+6].pts:=delta/(2.0*mem[12+2].pts
);
mem[b+5].pts:=0.0;
mem[b+3].pts:=desiredwidth+offset;
rebox:=b
END
END;
FUNCTION cleanbox(p:integer):integer;
BEGIN
IF p=0 THEN cleanbox:=nullbox
ELSE IF mem[p+5].pts=0.0 THEN
cleanbox:=p
ELSE cleanbox:=hpack(p,0,true)
END;
FUNCTION mlisttohlist(p,style:integer;
penalties:boolean):integer;
VAR q,r: integer;
qtype, rtype: integer;
curstyle, cursize: integer;
maxh, maxd: real;
kern: real;
drt: real;
shiftup,shiftdown: real;
b: integer;
d,g: integer;
curnode: integer;
t:real;
c: integer;
h: real;
j: integer;
clr: real;
s,pen: integer;
x: integer;
size: real;
qq: integer;
appendpenalty: boolean;
PROCEDURE donescripts;
BEGIN
IF mem[q+1].fourbytes.byte0<>0 THEN
BEGIN b:=mem[q+1].fourbytes.rhword;
maxh:=maximum(maxh,mem[b+4].pts-mem[b+5].pts);
maxd:=maximum(maxd,mem[b+2].pts+mem[b+5].pts)
END;
r:=q;
rtype:=qtype END;
PROCEDURE attachscripts;
VAR p,r,b,g:integer;
delta:real;
shiftscripts: boolean;
BEGIN
shiftscripts:=false;
IF mem[q+1].fourbytes.byte0<>0 THEN
BEGIN b:=mem[q+1].fourbytes.rhword;
IF qtype=1 THEN shiftscripts:=true
ELSE BEGIN c:=mem[b+1].twohalves.lhword;
IF c=0 THEN shiftscripts:=true
ELSE IF mem[c].twohalves.lhword<>0 THEN
shiftscripts:=true
ELSE
IF NOT(c>25000) THEN shiftscripts:=true
ELSE IF mem[b+5].pts<>0 THEN
shiftscripts:=true
END
END;
IF shiftscripts THEN BEGIN c:=fontsize[scrstyle[curstyle]];
shiftup:=mem[b+4].pts-mem[b+5].pts
-fmem[parbase[eqtb[c+2+1393].int
]+17].pts;
IF shiftup<0 THEN shiftup:=0.0;
shiftdown:=mem[b+2].pts+mem[b+5].pts
+fmem[parbase[eqtb[c+2+1393].int
]+18].pts;
IF shiftdown<0 THEN shiftdown:=0.0
END
ELSE BEGIN shiftup:=0.0;
shiftdown:=0.0
END;
IF mem[q+2].fourbytes.byte0=0 THEN
IF mem[q+3].fourbytes.byte0=0 THEN
ELSE BEGIN
d:=cleanbox(mem[q+3].fourbytes.rhword);
shiftdown:=
maximum(shiftdown,fmem[parbase[eqtb[cursize+2+1393].int
]+15].pts);
shiftdown:=maximum(shiftdown,
mem[d+4].pts-0.8*fmem[parbase[eqtb[cursize+2+1393].int
]+4].pts);
mem[d+5].pts:=shiftdown;
IF kern<>0 THEN
BEGIN g:=getnode(4);
mem[g].twohalves.rhword:=0;
mem[g+1].pts:=-kern;
mem[g+2].pts:=0.0;
mem[g+3].pts:=0.0;
p:=getnode(2);
mem[p].twohalves.byte2:=4;
mem[p+1].twohalves.lhword:=g;
mem[p].twohalves.lhword:=d;
d:=hpack(p,0,true)
END
END
ELSE BEGIN
shiftup:=
maximum(shiftup,fmem[parbase[eqtb[fontsize[curstyle]+2+1393].int
]+suptable[curstyle]].pts);
d:=cleanbox(mem[q+2].fourbytes
.rhword);
shiftup:=maximum(shiftup,fmem[parbase[eqtb[cursize+2+1393].int
]+4].pts/4+
mem[d+2].pts);
IF mem[q+3].fourbytes.byte0=0 THEN mem[d+5].pts:=-shiftup
ELSE BEGIN
shiftdown:=
maximum(shiftdown,fmem[parbase[eqtb[cursize+2+1393].int
]+16].pts);
c:=cleanbox(mem[q+3].fourbytes
.rhword);
delta:= mem[d+2].pts+mem[c+4].pts
+3*drt-(shiftup+shiftdown)
;
IF delta>0 THEN BEGIN shiftdown:=shiftdown+delta;
delta:=0.8*fmem[parbase[eqtb[cursize+2+1393].int
]+4].pts+mem[d+2].pts-shiftup;
IF delta>0 THEN BEGIN shiftup:=shiftup+delta;
shiftdown:=shiftdown-delta;
END;
END;
r:=getnode(2);
mem[r].twohalves.byte2:=4;
mem[r+1].twohalves.lhword:=0;
mem[d].twohalves.lhword:=r;
mem[r].twohalves.lhword:=c;
mem[c+5].pts:=-kern;
d:=vpack(d,shiftdown+shiftup+mem[d+4].pts
,false);
mem[d+5].pts:=shiftdown
END
END;
IF(mem[q+2].fourbytes.byte0<>0) OR
(mem[q+3].fourbytes.byte0<>0) THEN
WITH mem[q+1].fourbytes
DO
IF byte0=0 THEN BEGIN byte0:=1;
rhword:=d
END
ELSE BEGIN mem[b].twohalves
.lhword:=d;
rhword:=hpack(b,0,true)
END;
donescripts
END;
PROCEDURE createfraction;
VAR axis: real;
rt:real;
numraisecode,denomlowercode: integer;
num,denom: integer;
clr:real;
delta,delta1,delta2: real;
p,j: integer;
s: real;
ld,rd: integer;
BEGIN
WITH mem[q+2].fourbytes
DO IF byte0<>0 THEN num:=cleanbox(rhword)
ELSE num:=nullbox;
WITH mem[q+3].fourbytes
DO IF byte0<>0 THEN denom:=cleanbox(rhword)
ELSE denom:=nullbox;
rt:=mem[q+1].pts;
axis:=fmem[parbase[eqtb[cursize+2+1393].int
]+21].pts;
IF(curstyle MOD 4)=0 THEN
BEGIN numraisecode:=0;
denomlowercode:=0
END
ELSE BEGIN denomlowercode:=1;
IF rt=0.0 THEN numraisecode:=2
ELSE numraisecode:=1
END;
CASE numraisecode OF
0: shiftup:=fmem[parbase[eqtb[cursize+2+1393].int
]+7].pts;
1: shiftup:=fmem[parbase[eqtb[cursize+2+1393].int
]+8].pts;
2: shiftup:=fmem[parbase[eqtb[cursize+2+1393].int
]+9].pts;
OTHERS:
confusion
END;
CASE denomlowercode OF
0: shiftdown:=fmem[parbase[eqtb[cursize+2+1393].int
]+10].pts;
1: shiftdown:=fmem[parbase[eqtb[cursize+2+1393].int
]+11].pts;
OTHERS:
confusion
END;
IF mem[denom+3].pts<mem[num+3].pts
THEN
denom:=rebox(denom,mem[num+3].pts
,0)
ELSE IF mem[num+3].pts<mem[denom+3].pts
THEN
num:=rebox(num,mem[denom+3].pts
,0);
IF rt=0.0 THEN BEGIN
IF(curstyle MOD 4)=0 THEN clr:=7*drt
ELSE clr:=3*drt;
delta:=(mem[num+2].pts+mem[denom+4].pts
+clr)-(shiftup+shiftdown);
IF delta>0 THEN
BEGIN shiftup:=shiftup+delta/2;
shiftdown:=shiftdown+delta/2
END
END
ELSE BEGIN IF(curstyle MOD 4)=0
THEN clr:=3*rt
ELSE clr:=rt;
delta1:=(mem[num+2].pts+clr+rt/2)-(shiftup-axis);
delta2:=(mem[denom+4].pts+clr+rt/2)-(shiftdown+axis);
IF delta1>0 THEN
BEGIN
IF delta2>0 THEN BEGIN shiftup:=shiftup+delta1;
shiftdown:=shiftdown+delta2
END
ELSE shiftup:=shiftup+delta1-delta2
END
ELSE IF delta2>0 THEN shiftdown:=shiftdown+delta2-delta1
END;
r:=getnode(7);
mem[r].twohalves.byte2:=1;
mem[r+4].pts:=mem[num+4].pts
+shiftup;
mem[r+2].pts:=mem[denom+2].pts
+shiftdown;
mem[r+3].pts:=mem[num+3].pts
;
mem[r+5].pts:=0.0;
mem[r+1].twohalves.lhword:=num;
p:=getnode(2);
mem[p].twohalves.byte2:=4;
mem[p+1].twohalves.lhword:=0;
mem[num].twohalves.lhword:=p;
IF rt=0.0 THEN BEGIN mem[p].twohalves
.lhword:=denom;
mem[r+6].pts:=(shiftup+shiftdown-mem[num+2].pts
-mem[denom+4].pts)/
mem[0+2].pts
END
ELSE BEGIN
j:=fractionrule(rt);
mem[p].twohalves.lhword:=j;
mem[r+6].pts:=(shiftup-mem[num+2].pts
-rt/2-axis)/mem[0+2].pts;
p:=getnode(2);
mem[p].twohalves.byte2:=4;
mem[j].twohalves.lhword:=p;
j:=getnode(4);
mem[j+1].pts:=shiftdown+axis-mem[denom+4].pts
-rt/2;
mem[j+2].pts:=0.0;
mem[j+3].pts:=0.0;
mem[j].twohalves.rhword:=0;
mem[p+1].twohalves.lhword:=j;
mem[p].twohalves.lhword:=denom
END;
CASE denomlowercode OF
0: s:=fmem[parbase[eqtb[cursize+2+1393].int
]+19].pts;
1: s:=fmem[parbase[eqtb[cursize+2+1393].int
]+20].pts;
OTHERS:
confusion
END;
ld:=varsymbol(mem[q+4].fourbytes
,curstyle,s);
rd:=varsymbol(mem[q+5].fourbytes
,curstyle,s);
mem[ld+5].pts:=(mem[ld+4].pts
-mem[ld+2].pts)/2-axis;
mem[rd+5].pts:=(mem[rd+4].pts
-mem[rd+2].pts)/2-axis;
mem[ld].twohalves.lhword:=r;
mem[r].twohalves.lhword:=rd;
mem[q+1].fourbytes.rhword:=hpack(ld,0,true)
END;
PROCEDURE createoperator;
VAR b,upper,lower,middle,c,f,cicindex,change:integer;
maxw:real;
BEGIN
IF(mem[q+2].fourbytes.byte0=0) AND
(mem[q+3].fourbytes.byte0=0) THEN donescripts
ELSE BEGIN
IF mem[q+1].fourbytes.byte0=0 THEN b:=nullbox
ELSE b:=mem[q+1].fourbytes.rhword;
IF(NOT(b>25000)) AND(mem[b].twohalves
.byte2=0) THEN
BEGIN c:=mem[b+1].twohalves
.lhword;
IF(c>25000) AND(mem[c].twohalves
.lhword=0) THEN
WITH mem[c].twohalves
DO
IF(byte2=eqtb[3+1393].int) THEN BEGIN
cicindex:=fontinfo[byte2,byte3].byte2 DIV 4;
IF cicindex<>0 THEN kern:=fmem[icbase[byte2
]+cicindex].pts;
END;
END;
IF(curstyle MOD 4)<>0 THEN
attachscripts
ELSE BEGIN
change:=mem[q].twohalves.byte3;
IF kern<>0 THEN IF change=1
THEN change:=0
ELSE change:=1;
IF change<>0 THEN attachscripts
ELSE BEGIN
IF mem[q+2].fourbytes.byte0<>0 THEN
BEGIN upper:=cleanbox(mem[q+2].fourbytes
.rhword);
shiftup:=maximum(fmem[parbase[eqtb[3+1393].int
]+7+3].pts-mem[upper+2].pts,fmem[parbase[eqtb[3+1393].int
]+7+1].pts)
END
ELSE BEGIN upper:=nullbox;
shiftup:=0
END;
IF mem[q+3].fourbytes.byte0<>0 THEN
BEGIN lower:=cleanbox(mem[q+3].fourbytes
.rhword);
shiftdown:=maximum(fmem[parbase[eqtb[3+1393].int
]+7+4].pts-mem[lower+4].pts,fmem[parbase[eqtb[3+1393].int
]+7+2].pts);
END
ELSE BEGIN lower:=nullbox;
shiftdown:=0.0
END;
maxw:=mem[b+3].pts-kern;
IF mem[lower+3].pts>maxw THEN
maxw:=mem[lower+3].pts;
IF mem[upper+3].pts>maxw THEN
maxw:=mem[upper+3].pts;
upper:=rebox(upper,maxw,kern);
middle:=rebox(cleanbox(b),maxw,kern/2);
lower:=rebox(lower,maxw,0);
b:=getnode(7);
mem[b].twohalves.byte2:=1;
mem[b+3].pts:=maxw+kern;
mem[b+4].pts:=mem[middle+4].pts
-mem[middle+5].pts+mem[upper+2].pts
+mem[upper+4].pts;
IF shiftup<>0.0 THEN mem[b+4].pts
:=mem[b+4].pts+shiftup+fmem[parbase[eqtb[3+1393].int
]+7+5].pts;
mem[b+2].pts:=mem[middle+2].pts
+mem[middle+5].pts+mem[lower+4].pts
+mem[lower+2].pts;
IF shiftdown<>0.0 THEN mem[b+2].pts
:=mem[b+2].pts+shiftdown+fmem[parbase[eqtb[3+1393].int
]+7+5].pts;
mem[b+6].pts:=0.0;
mem[b+5].pts:=0.0;
IF shiftup=0.0 THEN mem[upper].twohalves
.lhword:=middle
ELSE BEGIN c:=getnode(4);
mem[c+1].pts:=shiftup;
mem[c+2].pts:=0.0;
mem[c+3].pts:=0.0;
mem[c].twohalves.rhword:=0;
f:=getnode(2);
mem[f].twohalves.byte2:=4;
mem[f+1].twohalves.lhword:=c;
mem[upper].twohalves.lhword:=f;
mem[f].twohalves.lhword:=middle;
c:=getnode(4);
mem[c+1].pts:=fmem[parbase[eqtb[3+1393].int
]+7+5].pts;
mem[c+2].pts:=0.0;
mem[c+3].pts:=0.0;
mem[c].twohalves.rhword:=0;
f:=getnode(2);
mem[f].twohalves.byte2:=4;
mem[f+1].twohalves.lhword:=c;
mem[f].twohalves.lhword:=upper;
upper:=f
END;
IF shiftdown=0 THEN mem[middle].twohalves
.lhword:=lower
ELSE BEGIN c:=getnode(4);
mem[c+1].pts:=shiftdown;
mem[c+2].pts:=0.0;
mem[c+3].pts:=0.0;
mem[c].twohalves.rhword:=0;
f:=getnode(2);
mem[f].twohalves.byte2:=4;
mem[f+1].twohalves.lhword:=c;
mem[middle].twohalves.lhword:=f;
mem[f].twohalves.lhword:=lower;
c:=getnode(4);
mem[c+1].pts:=fmem[parbase[eqtb[3+1393].int
]+7+5].pts;
mem[c+2].pts:=0.0;
mem[c+3].pts:=0.0;
mem[c].twohalves.rhword:=0;
f:=getnode(2);
mem[f].twohalves.byte2:=4;
mem[f+1].twohalves.lhword:=c;
mem[lower].twohalves.lhword:=f
END;
mem[b+1].twohalves.lhword:=upper;
WITH mem[q+1].fourbytes
DO BEGIN byte0:=1;
rhword:=b END;
donescripts
END
END
END
END;
BEGIN
IF p=0 THEN mlisttohlist:=0
ELSE
BEGIN
q:=p;
rtype:=-1;
r:=-1;
maxh:=0.0;
maxd:=0.0;
drt:= fmem[parbase[eqtb[3+1393].int
]+7].pts;
curstyle:=style;
cursize:=fontsize[curstyle];
WHILE q<>0 DO
BEGIN kern:=0.0;
qtype:= mem[q].twohalves.byte2;
CASE qtype OF
0:
BEGIN
IF(mem[q].twohalves.byte3<>0) AND
(mem[q+1].fourbytes.byte0<>0) THEN
BEGIN b:=mem[q+1].fourbytes.rhword;
IF mem[q].twohalves.byte3=1 THEN
mem[b+5].pts:=(mem[b+4].pts
-mem[b+2].pts)/2-fmem[parbase[eqtb[fontsize[curstyle]+2+1393].int
]+21].pts
ELSE
BEGIN
c:=mem[b+1].twohalves.lhword;
h:=0.0;
WHILE c<>0 DO
WITH mem[c].twohalves
DO
IF(c>25000) THEN
BEGIN h:=charht(byte2,byte3);
c:=0
END
ELSE BEGIN
IF byte2=4 THEN c:=0
ELSE IF(byte2=0) OR(byte2=1) OR(byte2=2) THEN
BEGIN h:=mem[c+4].pts;
c:=0
END
ELSE c:=mem[c].twohalves.lhword
END;
mem[b+5].pts:=mem[b+4].pts-h
END
END;
attachscripts
END;
4: attachscripts;
3,5,6:
BEGIN
IF rtype=2 THEN WITH mem[r].twohalves
DO BEGIN byte2:=0;
byte3:=0 END;
attachscripts
END;
2:BEGIN
IF(rtype=2) OR(rtype=1) OR(rtype=3)
OR(rtype=4)
OR(rtype=6) OR(rtype<0) THEN
WITH mem[q].twohalves
DO BEGIN byte2:=0;
byte3:=0 END;
attachscripts
END;
12,14:;
13: IF rtype=2 THEN WITH mem[r].twohalves
DO BEGIN byte2:=0;
byte3:=0 END;
15: BEGIN
curquad:=fmem[parbase[eqtb[cursize+2+1393].int
]+5].pts;
curxspace:=fmem[parbase[eqtb[cursize+2+1393].int
]+6].pts;
j:=mem[q].twohalves.byte3;
CASE j OF
0,1,2,3,
4,5,6,
7:
BEGIN curstyle:=j;
cursize:=fontsize[j]
END;
8: g:=mathglue(1/6,0,0);
15: IF cursize=0 THEN g:=mathglue(1/6,0,0)
ELSE g:=0;
9: IF cursize=0 THEN g:=mathglue(5/18,5/18,0)
ELSE g:=0;
10: g:=mathglue(1.0,0,0);
14: IF cursize=0 THEN g:=mathglue(2/9,1/9,2/9)
ELSE g:=mathglue(1/6,0,0);
11: g:=mathglue(-1/6,0,0);
16: IF cursize=0 THEN g:=mathglue(-1/6,0,0)
ELSE g:=0;
12: IF cursize=0 THEN g:=mathglue(-5/18,-5/18,0)
ELSE g:=0;
13: IF cursize=0 THEN g:=mathglue(-2/9,-1/9,-2/9)
ELSE g:=0;
17: IF cursize=0 THEN g:=mathglue(2/9,1/9,2/9)
ELSE g:=0;
18: BEGIN c:=mem[q].twohalves
.lhword;
d:=mem[mem[c+1].fourbytes.rhword+1].twohalves.lhword;
g:=mathglue(mem[d+1].pts/18.0,mem[d+2].pts
/18.0,mem[d+3].pts/18.0);
mem[q].twohalves.lhword:=mem[c].twohalves.lhword;
freeavail(c);
dsnodelist(d)
END;
OTHERS:
confusion
END;
IF j>=8 THEN BEGIN mem[q].twohalves
.byte2:=14;
WITH mem[q+1].fourbytes
DO BEGIN byte0:=3;
rhword:=g END
END
END;
7: BEGIN BEGIN
WITH mem[q+1].fourbytes
DO BEGIN IF byte0=0 THEN b:=nullbox
ELSE b:=cleanbox(rhword
);
byte0:=1;
END;
IF(curstyle MOD 4)=0 THEN
clr:=fmem[parbase[eqtb[cursize+2+1393].int
]+4].pts/4+drt
ELSE clr:=1.25*drt;
c:=varsymbol(eqtb[1419].fourbytes
,curstyle,mem[b+4].pts+mem[b+2].pts
+clr+drt);
mem[c+5].pts:=(mem[c+4].pts
-mem[c+2].pts-mem[b+4].pts
+mem[b+2].pts-clr-drt)/2;
IF penalties THEN h:=drt
ELSE
h:=2*drt;
mem[c].twohalves.lhword:=overbar(b,mem[c+4].pts-mem[c+5].pts
,drt,h);
mem[q+1].fourbytes.rhword:=hpack(c,0,true)
END;
attachscripts
END;
8: BEGIN BEGIN
IF penalties THEN h:=drt
ELSE
h:=2*drt;
WITH mem[q+1].fourbytes
DO
BEGIN
IF byte0=0 THEN b:=nullbox
ELSE b:=cleanbox(rhword
);
byte0:=1;
rhword:=overbar(b,mem[b+4].pts+3*drt,drt,h)
END
END;
attachscripts
END;
9: BEGIN BEGIN
b:=getnode(7);
WITH mem[q+1].fourbytes
DO
BEGIN
IF byte0=0 THEN d:=nullbox
ELSE d:=cleanbox(rhword
);
byte0:=1;
rhword:=b;
END;
mem[b].twohalves.byte2:=1;
mem[b+1].twohalves.lhword:=d;
mem[b+4].pts:=mem[d+4].pts;
mem[b+3].pts:=mem[d+3].pts;
mem[b+2].pts:=mem[d+2].pts+5*drt;
IF penalties THEN mem[b+2].pts
:=mem[b+2].pts-drt;
mem[b+6].pts:=2*drt/mem[0+2].pts
;
mem[b+5].pts:=0.0;
b:=getnode(2);
mem[b].twohalves.byte2:=4;
mem[b+1].twohalves.lhword:=0;
mem[d].twohalves.lhword:=b;
mem[b].twohalves.lhword:=fractionrule(drt);
END;
attachscripts
END;
11: BEGIN createfraction;
donescripts
END;
1: createoperator;
10: BEGIN WITH mem[q+4].fourbytes
DO d:=boxchar(byte2,byte3,curstyle,false);
WITH mem[q+1].fourbytes
DO IF byte0=0 THEN b:=nullbox
ELSE b:=cleanbox(rhword
);
c:=getnode(2);
mem[c].twohalves.byte2:=4;
mem[c+1].twohalves.lhword:=12;
mem[d].twohalves.lhword:=c;
mem[c].twohalves.lhword:=b;
mem[d+5].pts:=(mem[b+3].pts
-mem[d+3].pts)/2.0;
h:=mem[b+4].pts;
t:=fmem[parbase[eqtb[cursize+mem[p+4].fourbytes
.byte2+1393].int]+4].pts;
mem[d+3].pts:=0;
WITH mem[q+1].fourbytes
DO BEGIN byte0:=1;
rhword:=vpack(d,mem[d+4].pts+h-t,false)
END;
attachscripts
END;
OTHERS:
confusion
END;
q:=mem[q].twohalves.lhword
END;
mem[25003].twohalves.lhword:=0;
curnode:=25003;
q:=p;
rtype:=-1;
curstyle:=style;
cursize:=fontsize[curstyle];
WHILE q<>0 DO
BEGIN qtype:=mem[q].twohalves
.byte2;
s:=4;
pen:=-1;
CASE qtype OF
2: pen:=eqtb[1414].int;
3: pen:=eqtb[1415].int;
0,1,4,5,6:;
11: BEGIN s:=6;
qtype:=0
END;
7,8,9,10: qtype:=0;
12,13:
BEGIN t:=fmem[parbase[eqtb[fontsize[style]+2+1393].int
]+21].pts;
h:= maximum(maxh-t,maxd+t);;
size:=maximum(1.8*h,2*h-fmem[parbase[eqtb[fontsize[style]
+2+1393].int]+4].pts);
IF(qtype=12) THEN qtype:=4
ELSE
qtype:= 5;
b:= varsymbol(mem[q+1].fourbytes
,curstyle,size);
mem[b+5].pts:=((mem[b+4].pts
-mem[b+2].pts)/2)-t;
WITH mem[q+1].fourbytes
DO BEGIN byte0:=1;
rhword:= b END
END;
14: BEGIN s:=2;
x:=mem[q+1].fourbytes.rhword;
IF x=0 THEN
ELSE BEGIN
IF mem[x].twohalves.byte2=9 THEN WITH mem[x+1].twohalves
DO byte2:=eqtb[cursize+byte2+1393].int;
BEGIN
mem[curnode].twohalves.lhword:=x;
curnode:=x;
END
END
END;
15: BEGIN s:=2;
curstyle:= mem[q].twohalves.byte3;
cursize:=fontsize[curstyle];
END;
OTHERS:
confusion
END;
IF(qtype<>14) AND(qtype<>15)
THEN
BEGIN
IF rtype>=0 THEN BEGIN
c:=0;
curquad:=fmem[parbase[eqtb[cursize+2+1393].int
]+5].pts;
curxspace:=fmem[parbase[eqtb[cursize+2+1393].int
]+6].pts;
CASE spacetable[rtype,qtype] OF
7:;
8: c:=mathglue(1/6,0.0,0.0);
15: IF cursize=0 THEN c:=mathglue(1/6,0.0,0.0);
9: IF cursize=0 THEN c:=mathglue(5/18,5/18,0.0);
17: IF cursize=0 THEN c:=mathglue(2/9,1/9,2/9)
;
OTHERS:
confusion
END;
IF c<>0 THEN BEGIN
mem[curnode].twohalves.lhword:=c;
curnode:=c;
END
END;
BEGIN
mem[curnode].twohalves.lhword:=mem[q+1].fourbytes.rhword;
curnode:=mem[q+1].fourbytes.rhword;
END;
appendpenalty:=false;
IF(pen>=0) AND penalties THEN
BEGIN qq:=mem[q].twohalves.lhword;
IF qq=0 THEN appendpenalty:=true
ELSE IF mem[qq].twohalves.byte2<>14 THEN
appendpenalty:=true
ELSE BEGIN qq:=mem[qq+1].fourbytes
.rhword;
IF qq=0 THEN appendpenalty:=true
ELSE IF mem[qq].twohalves.byte2<>8 THEN
appendpenalty:= true
END
END;
IF appendpenalty THEN
BEGIN x:=getnode(2);
mem[x].twohalves.byte2:=8;
mem[x+1].int:=pen;
BEGIN
mem[curnode].twohalves.lhword:=x;
curnode:=x;
END
END;
rtype:=qtype
END;
c:=mem[q].twohalves.lhword;
IF s=1 THEN freeavail(q)
ELSE
freenode(q,s);
q:=c
END;
mlisttohlist:=mem[25003].twohalves
.lhword
END
END;
PROCEDURE boxfield(p:integer;
fieldoffset:integer;
style:integer;
corr:boolean);
FORWARD;
FUNCTION evalmlist(p,style:integer;
penalties:boolean):integer;
LABEL 2;
VAR q,t,curstyle:integer;
PROCEDURE evalopnoad;
VAR singlchrxop:boolean;
finf: bytes4;
BEGIN
WITH mem[q+1].fourbytes
DO
BEGIN
IF(byte0=2) AND(byte2=3) THEN
BEGIN
finf:=fontinfo[eqtb[3+1393].int
,byte3];
singlchrxop:=true;
IF((curstyle MOD 4)=0) AND((byte2
MOD 4)<>0)
THEN byte3:=finf.byte3
END
ELSE singlchrxop:=false;
END;
boxfield(q,1,curstyle,true);
IF singlchrxop THEN
WITH mem[q+1].fourbytes
DO
mem[rhword+5].pts:=
-fmem[parbase[eqtb[fontsize[curstyle]+2+1393].int
]+21].pts-0.5*mem[rhword+2].pts;
END;
BEGIN
q:=p;
curstyle:=style;
WHILE q<>0 DO
BEGIN
CASE mem[q].twohalves.byte2
OF
0,2,3,4,5,6,9,10:
boxfield(q,1,curstyle,(mem[q+2].fourbytes
.byte0<>0) OR(mem[q+3].fourbytes.byte0=0));
7,8: boxfield(q,1,undstyle[curstyle],true);
11: BEGIN
boxfield(q,2,numstyle[curstyle],true);
boxfield(q,3,denomstyle[curstyle],true);
GOTO 2;
END;
1: evalopnoad;
15: BEGIN IF mem[q].twohalves
.byte3<8 THEN curstyle:=mem[q].twohalves
.byte3;
GOTO 2;
END;
12,13,14: GOTO 2;
OTHERS:
confusion
END;
boxfield(q,2,scrstyle[curstyle],true);
WITH mem[q+2].fourbytes
DO
IF(byte0=1) AND(rhword<>0) THEN
mem[rhword+3].pts:=mem[rhword+3].pts
+fmem[parbase[eqtb[fontsize[scrstyle[curstyle]]+2+1393].int
]+5].pts/18.0;
boxfield(q,3,undstyle[scrstyle[curstyle]],true);
WITH mem[q+3].fourbytes
DO
IF(byte0=1) AND(rhword<>0) THEN
mem[rhword+3].pts:=mem[rhword+3].pts
+fmem[parbase[eqtb[fontsize[scrstyle[curstyle]]+2+1393].int
]+5].pts/18.0;
2:;
q:=mem[q].twohalves.lhword
END;
evalmlist:=mlisttohlist(p,style,penalties)
END;
PROCEDURE boxfield;
VAR b:integer;
BEGIN
WITH mem[p+fieldoffset].fourbytes DO
CASE byte0
OF
1, 0:;
3:
BEGIN
b:=evalmlist(rhword,style,false);
IF(b=0) OR(mem[b].twohalves
.lhword=0) THEN rhword:=b
ELSE rhword:=hpack(b,0,true);
byte0:=1
END;
2: BEGIN
rhword:=boxchar(byte2,byte3,style,corr);
byte0:=1
END;
OTHERS:
confusion
END
END;
PROCEDURE initalign;
LABEL 10,0,1,2;
VAR atype: integer;
p,q: integer;
itemtyp,itemval: integer;
initp: integer;
BEGIN
atype:=hashentry;
IF alignptr>=4 THEN overflow(286,4);
algnlststack[alignptr]:=alignlist;
algnrcrdstack[alignptr]:=alignrecord;
algnststack[alignptr]:=alignstate;
alignptr:=alignptr+1;
pushnest;
IF mode=167 THEN
BEGIN mode:=-1;
aux.pts:=auxstack[nestptr-2].pts;
END
ELSE BEGIN mode:=-abs(mode);
IF mode=-84 THEN aux.pts:=1.0
END;
mode:=-(85)-mode;
scanspec;
mode:=-(85)-mode;
newsavelevel(4);
alignlist:=getnode(5);
alignrecord:=alignlist;
mem[alignrecord+1].twohalves.lhword:=0;
mem[alignrecord+2].twohalves.lhword:=0;
alignstate:=-1000;
curcmd:=1;
pagewarning:=preambleof;
warnindex:=atype;
WHILE true DO
BEGIN
q:=eqtb[7].fourbytes.rhword;
mem[q].twohalves.rhword:=mem[q].twohalves.rhword+1;
mem[alignrecord+4].twohalves.lhword:=q;
IF curcmd=5 THEN GOTO 0;
mem[alignrecord].twohalves.lhword:=getnode(5);
alignrecord:=mem[alignrecord].twohalves
.lhword;
mem[alignrecord+2].twohalves.lhword:=65534;
itemtyp:=83;
itemval:=0;
q:=25004;
WHILE true DO
BEGIN
gettok;
WHILE((curcmd=79) AND(curchar=7))
DO
BEGIN initp:=scanglue;
pagewarning:=preambleof;
warnindex:=atype;
eqdefine(7,18,initp);
gettok
END;
IF((curcmd=4) OR(curcmd=5))
THEN
BEGIN backinput;
println(287);
error;
GOTO 1;
END;
IF curcmd=6 THEN GOTO 1;
BEGIN
p:=q;
q:=getavail;
mem[p].twohalves.lhword:=q;
mem[p].twohalves.byte2:=itemtyp;
IF itemtyp=0 THEN BEGIN p:=q;
q:=getavail;
mem[p].twohalves.lhword:=q;
mem[p].twohalves.rhword:=itemval
END
ELSE mem[p].twohalves.byte3:=itemval;
END;
itemtyp:=curtyp;
itemval:=curval;
END;
1:
mem[q].twohalves.byte2:=itemtyp;
IF itemtyp=0 THEN BEGIN p:=q;
q:=getavail;
mem[p].twohalves.lhword:=q;
mem[q].twohalves.rhword:=itemval
END
ELSE mem[q].twohalves.byte3:=itemval;
mem[q].twohalves.lhword:=0;
mem[alignrecord+1].twohalves.lhword:=
mem[25004].twohalves.lhword;
itemtyp:=83;
itemval:=0;
q:=25004;
WHILE true DO
BEGIN gettok;
WHILE((curcmd=79) AND(curchar=7))
DO
BEGIN initp:=scanglue;
pagewarning:=preambleof;
warnindex:=atype;
eqdefine(7,18,initp);
gettok
END;
IF(((curcmd=4) OR(curcmd=5))
AND(alignstate=-1000)) THEN GOTO 2;
IF(curcmd=6) THEN
BEGIN println(288);
error;
GOTO 10;
END;
BEGIN
p:=q;
q:=getavail;
mem[p].twohalves.lhword:=q;
mem[p].twohalves.byte2:=itemtyp;
IF itemtyp=0 THEN BEGIN p:=q;
q:=getavail;
mem[p].twohalves.lhword:=q;
mem[p].twohalves.rhword:=itemval
END
ELSE mem[p].twohalves.byte3:=itemval;
END;
itemtyp:=curtyp;
itemval:=curval;
10:
END;
2:
BEGIN
p:=q;
q:=getavail;
mem[p].twohalves.lhword:=q;
mem[p].twohalves.byte2:=itemtyp;
IF itemtyp=0 THEN BEGIN p:=q;
q:=getavail;
mem[p].twohalves.lhword:=q;
mem[p].twohalves.rhword:=itemval
END
ELSE mem[p].twohalves.byte3:=itemval;
END;
mem[q].twohalves.byte2:=15;
mem[q].twohalves.lhword:=0;
mem[alignrecord+2].twohalves.lhword:=
mem[25004].twohalves.lhword;
mem[alignrecord+3].pts:=0.0;
END;
0:;
pagewarning:=ok
END;
PROCEDURE startalignbox;
BEGIN
pushnest;
mode:=-(85)-mode;
IF abs(mode)=84 THEN aux.pts:=1.0
ELSE aux.pts:=
-(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0);
alignrecord:=mem[alignlist].twohalves.lhword
END;
PROCEDURE startunsetnode;
BEGIN
WITH curinput DO
BEGIN
pushnest;
IF mode=-84 THEN aux.pts:=1.0
ELSE aux.pts:=
-(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0);
pushinput;
state:=0;
IF(alignrecord<0) THEN mustquit;
loc:=mem[alignrecord+1].twohalves.lhword;
recovery.rhword:=1;
recovery.lhword:=loc;
END
END;
PROCEDURE aligndelim;
BEGIN
IF(alignrecord<0) OR(mem[alignrecord+2].twohalves.lhword=65534) THEN mustquit;
IF((curcmd=4) AND(mem[alignrecord].twohalves.lhword=0)) THEN
BEGIN println(289);
error
END
ELSE WITH curinput DO
BEGIN alignstate:=-1000;
pushinput;
state:=0;
loc:=mem[alignrecord+2].twohalves.lhword;
recovery.rhword:=2;
recovery.lhword:=loc;
IF curcmd=5 THEN alignrecord:=-alignrecord;
END;
END;
PROCEDURE finishunsetnode;
VAR p,q: integer;
BEGIN
q:=abs(alignrecord);
IF mode=-84 THEN BEGIN p:=hpackage(head,0,true);
dsnodelist(mem[25009].twohalves
.lhword);
IF mem[p+3].pts>mem[q+3].pts
THEN mem[q+3].pts:=mem[p+3].pts
END
ELSE BEGIN p:=vpackage(head,0,false,true);
IF(mem[p+4].pts+mem[p+2].pts
)>mem[q+3].pts
THEN mem[q+3].pts:=mem[p+4].pts
+mem[p+2].pts;
mem[p].twohalves.byte2:=13
END;
mem[p].twohalves.byte2:=13;
IF str>0 THEN mem[p+6].pts:=str;
popnest;
BEGIN
mem[curnode].twohalves.lhword:=p;
curnode:=p;
END
END;
PROCEDURE finishalignbox;
VAR p: integer;
BEGIN
IF mode=-84 THEN
BEGIN p:=hpackage(head,0,true);
dsnodelist(mem[25009].twohalves.lhword);
END
ELSE p:=vpackage(head,0,false,true);
popnest;
append(p)
END;
PROCEDURE endalign;
LABEL 1,2;
VAR p,prevp,pp: integer;
c: integer;
len: real;
q,qq: integer;
g,s:integer;
l: real;
BEGIN
curlev:=curlev-1;
saveptr:=saveptr-3;
len:=savestack[saveptr].pts;
WITH savestack[saveptr+1].fourbytes
DO c:=rhword;
prevp:=head;
p:=mem[prevp].twohalves.lhword;
WHILE p<>0 DO BEGIN
pp:=mem[p+1].twohalves.lhword;
IF(NOT(p>25000)) AND((mem[p].twohalves
.byte2=0) OR(mem[p].twohalves.byte2=1)) AND(pp<>0)
THEN BEGIN
IF(pp>25000) OR(mem[pp].twohalves
.byte2<>13) THEN pp:=0
END
ELSE pp:=0;
IF pp<>0
THEN BEGIN
alignrecord:=alignlist;
q:=25004;
mem[25004].twohalves.byte2:=0;
mem[25004].twohalves.byte3:=0;
WHILE true DO
BEGIN g:=mem[alignrecord+4].twohalves
.lhword;
s:=getnode(2);
mem[s].twohalves.byte2:=4;
mem[s+1].twohalves.lhword:=g;
mem[g].twohalves.rhword:=mem[g].twohalves.rhword+1;
mem[q].twohalves.lhword:=s;
q:=s;
alignrecord:=mem[alignrecord].twohalves
.lhword;
IF alignrecord=0 THEN GOTO 2;
IF(pp<>0)
THEN
BEGIN
IF mode=-1 THEN BEGIN
l:=mem[pp+3].pts;
mem[pp+4].pts:=mem[p+4].pts;
mem[pp+2].pts:=mem[p+2].pts;
mem[pp+3].pts:=mem[alignrecord+3].pts;
mem[pp].twohalves.byte2:=0
END
ELSE BEGIN
l:=mem[pp+4].pts+mem[pp+2].pts
;
mem[pp+3].pts:=mem[p+3].pts
;
mem[pp+4].pts:=mem[alignrecord+3].pts
-mem[pp+2].pts;
mem[pp].twohalves.byte2:=1
END;
IF(mem[pp+6].pts<>0) THEN mem[pp+6].pts
:=(mem[alignrecord+3].pts-l)/mem[pp+6].pts;
qq:=pp;
pp:=mem[pp].twohalves.lhword;
mem[qq].twohalves.lhword:=0;
END
ELSE BEGIN
qq:=getnode(7);
mem[qq+1].twohalves.lhword:=0;
IF mode=-1 THEN BEGIN
mem[qq].twohalves.byte2:=0;
mem[qq+3].pts:=mem[alignrecord+3].pts;
mem[qq+4].pts:=0.0;
END
ELSE BEGIN
mem[qq].twohalves.byte2:=1;
mem[qq+4].pts:=mem[alignrecord+3].pts
;
mem[qq+3].pts:=0.0;
END;
mem[qq+2].pts:=0.0;
mem[qq+5].pts:=0.0
END;
mem[q].twohalves.lhword:=qq;
q:=qq
END;
2:;
IF mode=-1 THEN
BEGIN pp:=hpackage(25004,len,(c<>0));
dsnodelist(mem[25009].twohalves
.lhword);
END
ELSE pp:=vpackage(25004,len,false,(c<>0));
mem[prevp].twohalves.lhword:=pp;
q:=p;
p:=mem[p].twohalves.lhword;
freenode(q,7);
mem[pp].twohalves.lhword:=p;
prevp:=pp;
END
ELSE BEGIN prevp:=p;
p:=mem[p].twohalves.lhword
END
END;
alignrecord:=alignlist;
WHILE true DO BEGIN
delgluelink(mem[alignrecord+4].twohalves
.lhword);
dslist(mem[alignrecord+1].twohalves
.lhword);
dslist(mem[alignrecord+2].twohalves
.lhword);
q:=mem[alignrecord].twohalves
.lhword;
freenode(alignrecord,5);
IF q=0 THEN GOTO 1
ELSE alignrecord:=q;
END;
1:;
auxstack[nestptr-1]:=aux;
p:=mem[head].twohalves.lhword;
popnest;
IF mode=167 THEN
BEGIN
g:=eqtb[4].fourbytes.rhword;
s:=getnode(2);
mem[s].twohalves.byte2:=4;
mem[s+1].twohalves.lhword:=g;
mem[g].twohalves.rhword:=mem[g].twohalves.rhword+1;
mem[25001].twohalves.lhword:=s;
mem[s].twohalves.lhword:=p;
s:=getnode(2);
mem[s].twohalves.byte2:=4;
mem[s+1].twohalves.lhword:=g;
mem[g].twohalves.rhword:=mem[g].twohalves.rhword+1;
mem[prevp].twohalves.lhword:=s;
mem[s].twohalves.lhword:=0;
curndstack[nestptr-1]:=s;
auxstack[nestptr-1]:=aux;
aux.int:=0
END
ELSE BEGIN mem[curnode].twohalves
.lhword:=p;
curnode:=prevp
END;
alignptr:=alignptr-1;
alignstate:=algnststack[alignptr];
alignrecord:=algnrcrdstack[alignptr];
alignlist:=algnlststack[alignptr]
END;
PROCEDURE movew(amount:real);
VAR amt:integer;
highbyte: integer;
BEGIN
amt:=trunc(3514.598*(amount))
;
IF amt=wamt THEN BEGIN dvi(w0);
dvibytecnt:=dvibytecnt+1
END
ELSE IF(amt>=0) THEN
BEGIN wamt:=amt;
IF(amt<32768) THEN
BEGIN dvi(w2);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi((amt DIV 256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi(amt MOD 256);
dvibytecnt:=dvibytecnt+1
END
END
ELSE IF(amt<8388608) THEN
BEGIN dvi(w3);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi((amt DIV 65536) MOD 256);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi((amt DIV 256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi(amt MOD 256);
dvibytecnt:=dvibytecnt+1
END
END
END
ELSE BEGIN dvi(w4);
dvibytecnt:=dvibytecnt+1;
BEGIN
highbyte:=amt DIV 16777216;
dvi((highbyte+256) MOD 256);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi(((amt-highbyte*16777216) DIV
65536) MOD 256);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi(((amt-highbyte*16777216) DIV
256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi((amt-highbyte*16777216) MOD
256);
dvibytecnt:=dvibytecnt+1
END
END;
END
END
END
ELSE BEGIN
wamt:=amt;
IF(-amt<32768) THEN
BEGIN
amt:=amt+65536;
dvi(w2);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi((amt DIV 256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi(amt MOD 256);
dvibytecnt:=dvibytecnt+1
END
END
ELSE IF(-amt<8388608) THEN
BEGIN
amt:=amt+16777216;
dvi(w3);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi((amt DIV 65536) MOD 256);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi((amt DIV 256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi(amt MOD 256);
dvibytecnt:=dvibytecnt+1
END
END
END
ELSE BEGIN
amt:=amt+fourbytesize;
dvi(w4);
dvibytecnt:=dvibytecnt+1;
BEGIN
highbyte:=amt DIV 16777216;
dvi((highbyte+256) MOD 256);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi(((amt-highbyte*16777216) DIV
65536) MOD 256);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi(((amt-highbyte*16777216) DIV
256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi((amt-highbyte*16777216) MOD
256);
dvibytecnt:=dvibytecnt+1
END
END;
END
END
END
END;
PROCEDURE movex(amount:real);
VAR amt:integer;
highbyte: integer;
BEGIN
amt:=trunc(3514.598*(amount))
;
IF amt=xamt THEN BEGIN dvi(x0);
dvibytecnt:=dvibytecnt+1
END
ELSE IF(amt>=0) THEN
BEGIN xamt:=amt;
IF(amt<32768) THEN
BEGIN dvi(x2);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi((amt DIV 256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi(amt MOD 256);
dvibytecnt:=dvibytecnt+1
END
END
ELSE IF(amt<8388608) THEN
BEGIN dvi(x3);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi((amt DIV 65536) MOD 256);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi((amt DIV 256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi(amt MOD 256);
dvibytecnt:=dvibytecnt+1
END
END
END
ELSE BEGIN dvi(x4);
dvibytecnt:=dvibytecnt+1;
BEGIN
highbyte:=amt DIV 16777216;
dvi((highbyte+256) MOD 256);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi(((amt-highbyte*16777216) DIV
65536) MOD 256);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi(((amt-highbyte*16777216) DIV
256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi((amt-highbyte*16777216) MOD
256);
dvibytecnt:=dvibytecnt+1
END
END;
END
END
END
ELSE BEGIN
xamt:=amt;
IF(-amt<32768) THEN
BEGIN
amt:=amt+65536;
dvi(x2);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi((amt DIV 256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi(amt MOD 256);
dvibytecnt:=dvibytecnt+1
END
END
ELSE IF(-amt<8388608) THEN
BEGIN
amt:=amt+16777216;
dvi(x3);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi((amt DIV 65536) MOD 256);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi((amt DIV 256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi(amt MOD 256);
dvibytecnt:=dvibytecnt+1
END
END
END
ELSE BEGIN
amt:=amt+fourbytesize;
dvi(x4);
dvibytecnt:=dvibytecnt+1;
BEGIN
highbyte:=amt DIV 16777216;
dvi((highbyte+256) MOD 256);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi(((amt-highbyte*16777216) DIV
65536) MOD 256);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi(((amt-highbyte*16777216) DIV
256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi((amt-highbyte*16777216) MOD
256);
dvibytecnt:=dvibytecnt+1
END
END;
END
END
END
END;
PROCEDURE movey(amount:real);
VAR amt:integer;
highbyte: integer;
BEGIN
amt:=trunc(3514.598*(amount))
;
IF amt=yamt THEN BEGIN dvi(y0);
dvibytecnt:=dvibytecnt+1
END
ELSE IF(amt>=0) THEN
BEGIN yamt:=amt;
IF(amt<32768) THEN
BEGIN dvi(y2);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi((amt DIV 256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi(amt MOD 256);
dvibytecnt:=dvibytecnt+1
END
END
ELSE IF(amt<8388608) THEN
BEGIN dvi(y3);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi((amt DIV 65536) MOD 256);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi((amt DIV 256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi(amt MOD 256);
dvibytecnt:=dvibytecnt+1
END
END
END
ELSE BEGIN dvi(y4);
dvibytecnt:=dvibytecnt+1;
BEGIN
highbyte:=amt DIV 16777216;
dvi((highbyte+256) MOD 256);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi(((amt-highbyte*16777216) DIV
65536) MOD 256);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi(((amt-highbyte*16777216) DIV
256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi((amt-highbyte*16777216) MOD
256);
dvibytecnt:=dvibytecnt+1
END
END;
END
END
END
ELSE BEGIN
yamt:=amt;
IF(-amt<32768) THEN
BEGIN
amt:=amt+65536;
dvi(y2);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi((amt DIV 256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi(amt MOD 256);
dvibytecnt:=dvibytecnt+1
END
END
ELSE IF(-amt<8388608) THEN
BEGIN
amt:=amt+16777216;
dvi(y3);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi((amt DIV 65536) MOD 256);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi((amt DIV 256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi(amt MOD 256);
dvibytecnt:=dvibytecnt+1
END
END
END
ELSE
BEGIN
amt:=amt+fourbytesize;
dvi(y4);
dvibytecnt:=dvibytecnt+1;
highbyte:=amt DIV 16777216;
dvi((highbyte+256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi(((amt-highbyte*16777216) DIV 65536) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi(((amt-highbyte*16777216) DIV 256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi((amt-highbyte*16777216) MOD 256);
dvibytecnt:=dvibytecnt+1
END
END
END;
PROCEDURE movez(amount:real);
VAR amt:integer; highbyte: integer;
BEGIN
amt:=trunc(3514.598*(amount));
IF amt=zamt THEN BEGIN dvi(z0);
dvibytecnt:=dvibytecnt+1
END
ELSE IF(amt>=0) THEN
BEGIN zamt:=amt;
IF(amt<32768) THEN
BEGIN dvi(z2);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi((amt DIV 256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi(amt MOD 256);
dvibytecnt:=dvibytecnt+1
END
END
ELSE IF(amt<8388608) THEN
BEGIN dvi(z3);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi((amt DIV 65536) MOD 256);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi((amt DIV 256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi(amt MOD 256);
dvibytecnt:=dvibytecnt+1
END
END
END
ELSE BEGIN dvi(z4);
dvibytecnt:=dvibytecnt+1;
BEGIN
highbyte:=amt DIV 16777216;
dvi((highbyte+256) MOD 256);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi(((amt-highbyte*16777216) DIV
65536) MOD 256);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi(((amt-highbyte*16777216) DIV
256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi((amt-highbyte*16777216) MOD
256);
dvibytecnt:=dvibytecnt+1
END
END;
END
END
END
ELSE BEGIN
zamt:=amt;
IF(-amt<32768) THEN
BEGIN
amt:=amt+65536;
dvi(z2);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi((amt DIV 256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi(amt MOD 256);
dvibytecnt:=dvibytecnt+1
END
END
ELSE IF(-amt<8388608) THEN
BEGIN
amt:=amt+16777216;
dvi(z3);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi((amt DIV 65536) MOD 256);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi((amt DIV 256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi(amt MOD 256);
dvibytecnt:=dvibytecnt+1
END
END
END
ELSE BEGIN
amt:=amt+fourbytesize;
dvi(z4);
dvibytecnt:=dvibytecnt+1;
BEGIN
highbyte:=amt DIV 16777216;
dvi((highbyte+256) MOD 256);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi(((amt-highbyte*16777216) DIV
65536) MOD 256);
dvibytecnt:=dvibytecnt+1;
BEGIN
dvi(((amt-highbyte*16777216) DIV
256) MOD 256);
dvibytecnt:=dvibytecnt+1;
dvi((amt-highbyte*16777216) MOD
256);
dvibytecnt:=dvibytecnt+1
END
END;
END
END
END
END;
PROCEDURE right(amount:real);
BEGIN
IF amount<>0.0 THEN movex(amount);
x:=x+amount
END;
PROCEDURE rightto(xxx:real);
VAR righttot:real;
BEGIN righttot:=xxx-x;
right(righttot)
END;
PROCEDURE ydown(amount:real);
BEGIN
IF(amount<>0.0) THEN movey(amount);
y:=y+amount
END;
PROCEDURE zdown(amount:real);
BEGIN
IF(amount<>0.0) THEN movez(amount);
y:=y+amount
END;
FUNCTION gluesize(rglue:integer; gluefactor:real):real;
BEGIN
IF(gluefactor=0) THEN gluesize:=mem[rglue+1].pts
ELSE IF(gluefactor>0) THEN
gluesize:=mem[rglue+1].pts+mem[rglue+2].pts*gluefactor
ELSE gluesize:=mem[rglue+1].pts+mem[rglue+3].pts*gluefactor
END;
PROCEDURE hlistout(p:integer);
FORWARD;
PROCEDURE vlistout(p:integer);
VAR
q:integer;
g: real;
h,w,d:real;
i:integer;
pshx,pshy:real;
pshxamt,pshwamt:integer;
pshyamt,pshzamt:integer;
hlistqq:integer;
leaderq:integer;
leaderhh,leadlimity:real;
depth,height,width:real;
leadquot:integer;
leadrem: real;
yy: real;
BEGIN
q:=mem[p+1].twohalves.lhword;
g:=mem[p+6].pts;
WHILE(q<>0) DO
BEGIN
IF(q>25000) THEN
WITH mem[q].twohalves
DO
BEGIN
IF(lastfont<>byte2) THEN
BEGIN lastfont:=byte2;
dvi(fontnum+byte2);
fontused[byte2]:=1;
dvibytecnt:=dvibytecnt+1
END;
ydown(charht(byte2,byte3));
dvi(horzchar);
dvibytecnt:=dvibytecnt+1;
dvi(byte3);
dvibytecnt:=dvibytecnt+1;
ydown(chardp(byte2,byte3));
END
ELSE CASE mem[q].twohalves.byte2
OF
4: ydown(gluesize(mem[q+1].twohalves
.lhword,g));
6: ydown(mem[q+1].pts);
2: BEGIN
h:=mem[q+4].pts+mem[q+2].pts
;
ydown(h);
IF(mem[q+3].pts<=-100000.0)
THEN w:=mem[p+3].pts
ELSE w:=mem[q+3].pts;
dvi(horzrule);
dvibytecnt:=dvibytecnt+1;
IF h>0.0 THEN intout(trunc(3514.598*(h)))
ELSE intout(0);
IF w>0.0 THEN intout(trunc(3514.598*(w)))
ELSE intout(0);
dvibytecnt:=dvibytecnt+8;
END;
3: voutext(q,x,y);
1: BEGIN
BEGIN
dvi(dvipush);
dvibytecnt:=dvibytecnt+1;
pshx:=x;
pshy:=y;
pshwamt:=wamt;
pshxamt:=xamt;
pshyamt:=yamt;
pshzamt:=zamt;
END;
right(mem[q+5].pts);
vlistout(q);
BEGIN
dvi(dvipop);
dvibytecnt:=dvibytecnt+1;
x:=pshx;
y:=pshy;
wamt:=pshwamt;
xamt:=pshxamt;
yamt:=pshyamt;
zamt:=pshzamt;
END;
ydown(mem[q+4].pts+mem[q+2].pts)
END;
0: BEGIN
zdown(mem[q+4].pts);
BEGIN
dvi(dvipush);
dvibytecnt:=dvibytecnt+1;
pshx:=x;
pshy:=y;
pshwamt:=wamt;
pshxamt:=xamt;
pshyamt:=yamt;
pshzamt:=zamt;
END;
right(mem[q+5].pts);
hlistout(q);
BEGIN
dvi(dvipop);
dvibytecnt:=dvibytecnt+1;
x:=pshx;
y:=pshy;
wamt:=pshwamt;
xamt:=pshxamt;
yamt:=pshyamt;
zamt:=pshzamt;
END;
hlistqq:=mem[q].twohalves.lhword;
IF(NOT(hlistqq>25000)) AND
(mem[hlistqq].twohalves.byte2=4) THEN BEGIN
ydown(mem[q+2].pts+gluesize(mem[hlistqq+1].twohalves
.lhword,g));
q:=hlistqq
END
ELSE ydown(mem[q+2].pts)
END;
5: BEGIN
leaderq:=mem[q+1].twohalves.lhword;
depth:=mem[leaderq+2].pts;
height:=mem[leaderq+4].pts;
IF mem[leaderq].twohalves.byte2<>2 THEN
BEGIN
leaderhh:=height+depth;
IF(leaderhh<0) THEN leaderhh:=0
END
ELSE leaderhh:=-1.0;
IF(leaderhh<>0) AND(NOT(mem[q].twohalves
.lhword>25000)) AND(mem[mem[q].twohalves
.lhword].twohalves.byte2=4) THEN
BEGIN
q:=mem[q].twohalves.lhword;
h:=gluesize(mem[q+1].twohalves
.lhword,g);
leadlimity:=y+h;
IF(leaderhh>0) THEN
BEGIN
IF mem[leaderq+5].pts=0 THEN
BEGIN
leadquot:=trunc((y/leaderhh)-(0.000001*0.000001*0.00000001)
);
yy:=leaderhh*(leadquot+1);
END
ELSE BEGIN
leadquot:=trunc(h/leaderhh);
leadrem:=h-leadquot*leaderhh;
IF mem[leaderq+5].pts<0 THEN
yy:=y+leadrem/2
ELSE BEGIN
yy:=y+leadrem/(q+1);
leaderhh:=leaderhh+leadrem/(q+1);
END;
END;
ydown(yy-y);
IF mem[leaderq].twohalves.byte2=1 THEN
WHILE(y+leaderhh<=leadlimity+0.1)
DO
BEGIN
BEGIN
dvi(dvipush);
dvibytecnt:=dvibytecnt+1;
pshx:=x;
pshy:=y;
pshwamt:=wamt;
pshxamt:=xamt;
pshyamt:=yamt;
pshzamt:=zamt;
END;
vlistout(leaderq);
BEGIN
dvi(dvipop);
dvibytecnt:=dvibytecnt+1;
x:=pshx;
y:=pshy;
wamt:=pshwamt;
xamt:=pshxamt;
yamt:=pshyamt;
zamt:=pshzamt;
END;
ydown(leaderhh)
END
ELSE WHILE(y+leaderhh<=leadlimity+0.1)
DO
BEGIN
ydown(height);
BEGIN
dvi(dvipush);
dvibytecnt:=dvibytecnt+1;
pshx:=x;
pshy:=y;
pshwamt:=wamt;
pshxamt:=xamt;
pshyamt:=yamt;
pshzamt:=zamt;
END;
hlistout(leaderq);
BEGIN
dvi(dvipop);
dvibytecnt:=dvibytecnt+1;
x:=pshx;
y:=pshy;
wamt:=pshwamt;
xamt:=pshxamt;
yamt:=pshyamt;
zamt:=pshzamt;
END;
zdown(depth)
END
END
ELSE BEGIN
ydown(h);
dvi(horzrule);
dvibytecnt:=dvibytecnt+1;
IF h>0.0 THEN intout(trunc(3514.598
*(h)))
ELSE intout(0);
width:=mem[leaderq+3].pts;
IF width>0.0 THEN intout(trunc(3514.598*(width)))
ELSE intout(0);
dvibytecnt:=dvibytecnt+8
END;
ydown(leadlimity-y)
END
END;
OTHERS:
END;
q:=mem[q].twohalves.lhword
END;
END;
PROCEDURE hlistout;
VAR
q:integer;
g:real;
h,w,d:real;
i:integer;
pshx,pshy:real;
pshxamt,pshwamt:integer;
pshyamt,pshzamt:integer;
speclastglue:integer;
lastgluesize:real;
leaderq:integer;
leaderww:real;
depth,height,width:real;
leadlimitx:real;
leadquot:integer;
leadrem: real;
xx: real;
BEGIN
speclastglue:=-1;
q:=mem[p+1].twohalves.lhword;
g:=mem[p+6].pts;
WHILE(q<>0) DO BEGIN
IF((q>25000)) THEN
WITH mem[q].twohalves
DO
BEGIN
IF(lastfont<>byte2) THEN
BEGIN lastfont:=byte2;
dvi(fontnum+byte2);
fontused[byte2]:=1;
dvibytecnt:=dvibytecnt+1;
END;
dvi(byte3);
dvibytecnt:=dvibytecnt+1;
x:=x+charwd(byte2,byte3)
END
ELSE CASE mem[q].twohalves.byte2
OF
4: BEGIN
IF(mem[q+1].twohalves.lhword=speclastglue) THEN
BEGIN dvi(w0);
dvibytecnt:=dvibytecnt+1
END
ELSE BEGIN speclastglue:=mem[q+1].twohalves
.lhword;
lastgluesize:=gluesize(speclastglue,g);
movew(lastgluesize)
END;
x:=x+lastgluesize
END;
6: right(mem[q+1].pts);
2: BEGIN
w:=mem[q+3].pts;
IF(mem[q+4].pts<=-100000.0)
THEN h:=mem[p+4].pts
ELSE h:=mem[q+4].pts
;
IF(mem[q+2].pts<=-100000.0)
THEN d:=mem[p+2].pts
ELSE d:=mem[q+2].pts
;
IF d<>0 THEN
BEGIN
BEGIN
dvi(dvipush);
dvibytecnt:=dvibytecnt+1;
pshx:=x;
pshy:=y;
pshwamt:=wamt;
pshxamt:=xamt;
pshyamt:=yamt;
pshzamt:=zamt;
END;
ydown(d);
dvi(horzrule);
dvibytecnt:=dvibytecnt+1;
IF(h+d)>0.0 THEN intout(trunc(3514.598
*(h+d)))
ELSE intout(0);
IF w>0.0 THEN intout(trunc(3514.598
*(w)))
ELSE intout(0);
dvibytecnt:=dvibytecnt+8;
BEGIN
dvi(dvipop);
dvibytecnt:=dvibytecnt+1;
x:=pshx;
y:=pshy;
wamt:=pshwamt;
xamt:=pshxamt;
yamt:=pshyamt;
zamt:=pshzamt;
END;
right(w)
END
ELSE BEGIN
dvi(vertrule);
dvibytecnt:=dvibytecnt+1;
IF h>0.0 THEN intout(trunc(3514.598
*(h)))
ELSE intout(0);
IF w>0.0 THEN intout(trunc(3514.598
*(w)))
ELSE intout(0);
dvibytecnt:=dvibytecnt+8;
x:=x+w
END
END;
3: houtext(q,x,y);
1: BEGIN
BEGIN
dvi(dvipush);
dvibytecnt:=dvibytecnt+1;
pshx:=x;
pshy:=y;
pshwamt:=wamt;
pshxamt:=xamt;
pshyamt:=yamt;
pshzamt:=zamt;
END;
ydown(-mem[q+4].pts+mem[q+5].pts
);
vlistout(q);
BEGIN
dvi(dvipop);
dvibytecnt:=dvibytecnt+1;
x:=pshx;
y:=pshy;
wamt:=pshwamt;
xamt:=pshxamt;
yamt:=pshyamt;
zamt:=pshzamt;
END;
right(mem[q+3].pts);
END;
0: BEGIN
BEGIN
dvi(dvipush);
dvibytecnt:=dvibytecnt+1;
pshx:=x;
pshy:=y;
pshwamt:=wamt;
pshxamt:=xamt;
pshyamt:=yamt;
pshzamt:=zamt;
END;
ydown(mem[q+5].pts);
hlistout(q);
BEGIN
dvi(dvipop);
dvibytecnt:=dvibytecnt+1;
x:=pshx;
y:=pshy;
wamt:=pshwamt;
xamt:=pshxamt;
yamt:=pshyamt;
zamt:=pshzamt;
END;
right(mem[q+3].pts);
END;
5: BEGIN
leaderq:=mem[q+1].twohalves.lhword;
depth:=mem[leaderq+2].pts;
height:=mem[leaderq+4].pts;
width:=mem[leaderq+3].pts;
IF mem[leaderq].twohalves.byte2<>2 THEN
BEGIN leaderww:=width;
IF leaderww<0 THEN leaderww:=0;
END
ELSE leaderww:=-1.0;
IF(leaderww<>0) AND(NOT(mem[q].twohalves
.lhword>25000)) AND(mem[mem[q].twohalves
.lhword].twohalves.byte2=4) THEN
BEGIN
q:=mem[q].twohalves.lhword;
w:=gluesize(mem[q+1].twohalves
.lhword,g);
IF leaderww>0 THEN
BEGIN
IF mem[leaderq+5].pts=0 THEN
BEGIN
leadquot:=trunc((x/leaderww)-(0.000001*0.000001*0.00000001)
);
xx:=leaderww*(leadquot+1);
END
ELSE BEGIN leadquot:=trunc(w/leaderww);
leadrem:=w-leadquot*leaderww;
IF mem[leaderq+5].pts<0 THEN
xx:=x+leadrem/2
ELSE BEGIN
xx:=x+leadrem/(leadquot+1);
leaderww:=leaderww+leadrem/(leadquot+1);
END;
END;
leadlimitx:=x+w;
right(xx-x);
IF(mem[leaderq].twohalves.byte2=0) THEN
WHILE(x+leaderww<=leadlimitx+0.1)
DO
BEGIN
BEGIN
dvi(dvipush);
dvibytecnt:=dvibytecnt+1;
pshx:=x;
pshy:=y;
pshwamt:=wamt;
pshxamt:=xamt;
pshyamt:=yamt;
pshzamt:=zamt;
END;
hlistout(leaderq);
BEGIN
dvi(dvipop);
dvibytecnt:=dvibytecnt+1;
x:=pshx;
y:=pshy;
wamt:=pshwamt;
xamt:=pshxamt;
yamt:=pshyamt;
zamt:=pshzamt;
END;
right(leaderww)
END
ELSE WHILE(x+leaderww<=leadlimitx+0.1)
DO
BEGIN
BEGIN
dvi(dvipush);
dvibytecnt:=dvibytecnt+1;
pshx:=x;
pshy:=y;
pshwamt:=wamt;
pshxamt:=xamt;
pshyamt:=yamt;
pshzamt:=zamt;
END;
ydown(-height);
vlistout(leaderq);
BEGIN
dvi(dvipop);
dvibytecnt:=dvibytecnt+1;
x:=pshx;
y:=pshy;
wamt:=pshwamt;
xamt:=pshxamt;
yamt:=pshyamt;
zamt:=pshzamt;
END;
right(leaderww)
END;
right(leadlimitx-x)
END
ELSE BEGIN
dvi(vertrule);
dvibytecnt:=dvibytecnt+1;
IF(height+depth)>0.0 THEN
intout(trunc(3514.598*(height+depth))
)
ELSE intout(0);
IF w>0.0 THEN intout(trunc(3514.598
*(w)))
ELSE intout(0);
dvibytecnt:=dvibytecnt+8;
x:=x+w
END
END
END;
9: IF mem[q].twohalves.byte3=0 THEN BEGIN q:=q+1;
WITH mem[q].twohalves
DO
BEGIN
IF(lastfont<>byte2) THEN
BEGIN lastfont:=byte2;
dvi(fontnum+byte2);
fontused[byte2]:=1;
dvibytecnt:=dvibytecnt+1;
END;
dvi(byte3);
dvibytecnt:=dvibytecnt+1;
x:=x+charwd(byte2,byte3)
END;
q:=q-1 END;
OTHERS:
END;
q:=mem[q].twohalves.lhword
END;
END;
PROCEDURE shipout(p:integer);
VAR i: integer;
BEGIN
IF nooutputyet THEN BEGIN declareofil(-3);
nooutputyet:=false
END;
IF(maxpagewidth<mem[p+3].pts) THEN maxpagewidth:=mem[p+3].pts;
IF(maxpageheight<(mem[p+4].pts+mem[p+2].pts)) THEN
maxpageheight:=mem[p+4].pts+mem[p+2].pts;
x:=0.0;
y:=0.0;
wamt:=2147483647;
xamt:=2147483647;
yamt:=2147483647;
zamt:=2147483647;
lastfont:=-1;
thispageptr:=dvibytecnt;
dvi(bop);
dvibytecnt:=dvibytecnt+1;
FOR i:=48 TO 57 DO intout(savedknt[i]);
dvibytecnt:=dvibytecnt+40;
intout(lastpageptr);
dvibytecnt:=dvibytecnt+4;
vlistout(p);
dvi(eop);
dvibytecnt:=dvibytecnt+1;
lastpageptr:=thispageptr;
END;
PROCEDURE initout;
VAR i: integer;
BEGIN
dvibytecnt:=0;
lastpageptr:=-1;
nooutputyet:= true;
FOR i:=0 TO 63 DO fontused[i]:=0;
END;
FUNCTION boxbegin: integer;
LABEL 50;
VAR c,d,p,q: integer;
BEGIN
IF curchar>3 THEN
BEGIN
pushnest;
mode:=3-curchar;
IF mode=-1 THEN
aux.pts:=-(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0)
ELSE aux.pts:=1.0;
saveptr:=saveptr+1;
scanspec;
newsavelevel(12);
WITH savestack[saveptr-2].fourbytes DO
IF rhword=2 THEN
BEGIN chrcode.int:=32767;
chcodedef(1405,chrcode);
chrcode.int:=0;
chcodedef(1406,chrcode);
END;
boxbegin:=1;
GOTO 50;
END;
CASE curchar OF
0: BEGIN
IF outputdormant THEN BEGIN action:=21;
boxbegin:=0;
GOTO 50;
END;
curbox:=savedpage;
savedpage:=0;
END;
1,2: BEGIN c:=curchar;
d:=scandigit;
curbox:=savedbox[d];
IF c=1 THEN savedbox[d]:=0
ELSE
savedbox[d]:=boxcopy(curbox)
END;
3:
BEGIN
IF(abs(mode)<>167) AND((mem[curnode].twohalves
.byte2=0) OR(mem[curnode].twohalves.byte2=1)) THEN
BEGIN
p:=head;
q:=mem[head].twohalves.lhword;
WHILE(q<>curnode) DO BEGIN p:=q;
q:=mem[p].twohalves.lhword
END;
mem[p].twohalves.lhword:=0;
curbox:=curnode;
curnode:=p;
END
ELSE curbox:=0
END;
OTHERS:
confusion
END;
action:=15;
boxbegin:=0;
50:
END;
PROCEDURE boxjust;
VAR len: real;
c, q: integer;
BEGIN
len:=savestack[saveptr+1].pts;
WITH savestack[saveptr+2].fourbytes DO c:=rhword;
IF mode=-1 THEN curbox:=vpackage(head,len,false,c<>0)
ELSE IF c<>2 THEN
BEGIN
curbox:=hpackage(head,len,c<>0);
dsnodelist(mem[25009].twohalves.lhword);
END
ELSE BEGIN q:=getnode(2);
mem[q].twohalves.byte2:=8;
mem[q+1].int:=32767;
BEGIN
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END;
q:=getnode(2);
mem[q].twohalves.byte2:=4;
mem[q+1].twohalves.lhword:=eqtb[11].fourbytes.rhword;
mem[eqtb[11].fourbytes.rhword].twohalves.rhword:=
mem[eqtb[11].fourbytes.rhword].twohalves.rhword+1;
BEGIN
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END;
mem[25003].twohalves.lhword:=mem[head].twohalves.lhword;
mem[head].twohalves.lhword:=0;
curnode:=head;
mode:=-1;
aux.pts:=-(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0);
justification(len,inhangbegin,inhangfirst,inhangwidth,false);
curbox:=vpackage(head,0,false,true);
END;
END;
FUNCTION boxfinish: integer;
LABEL 50;
VAR j: integer;
q: integer;
BEGIN
WITH savestack[saveptr].fourbytes
DO j:=rhword;
IF((j>=48) AND(j<=57))
THEN
BEGIN
IF savedbox[j]<>0 THEN dsnodelist(savedbox[j]);
savedbox[j]:= curbox;
END
ELSE IF curbox<>0 THEN
BEGIN
IF(j>=58) AND(j<=60) THEN
BEGIN
IF mem[curbox].twohalves.byte2<>2 THEN mem[curbox+5].pts:=j-59;
q:=getnode(2);
mem[q].twohalves.byte2:=5;
mem[q+1].twohalves.lhword:=curbox;
BEGIN
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END;
END
ELSE BEGIN
mem[curbox+5].pts:=savestack[saveptr].pts
;
IF abs(mode)=167 THEN BEGIN action:=19;
boxfinish:=0;
GOTO 50;
END;
append(curbox);
END;
IF mode=1 THEN BEGIN action:=7;
boxfinish:=0;
GOTO 50;
END;
END;
boxfinish:=1;
50:
END;
FUNCTION moretopage: integer;
LABEL 50;
VAR c,d: integer;
p,q: integer;
pp,pq,qq,pr: integer;
newht, newshr, olddp: real;
breakpage: boolean;
BEGIN
IF mem[25001].twohalves.lhword=0 THEN
BEGIN
IF nestptr=0 THEN curnode:=25001
ELSE curndstack[0]:=25001;
moretopage:=1;
GOTO 50;
END;
IF pagetail=25002 THEN BEGIN
curbreak:=0;
curbadness:=(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0);
pagesize:=pagemem[1];
pagemaxdepth:=pagemem[2];
pagetopbl:=pagemem[4];
pageheight:=0.0;
pagestretch:=0.0;
pageshrink:=0.0;
pagedepth:=0.0;
pageinsdepth[0]:=0.0;
pageinsdepth[1]:=0.0;
insabsent[0]:=true;
insabsent[1]:=true;
END;
c:=mem[pagetail].twohalves.byte2;
CASE mem[mem[25001].twohalves
.lhword].twohalves.byte2
OF
0, 1, 2:
BEGIN
newht:=mem[mem[25001].twohalves
.lhword+4].pts;
olddp:=pagedepth;
pagedepth:=mem[mem[25001].twohalves
.lhword+2].pts;
IF pagedepth>pagemaxdepth THEN
BEGIN newht:=newht+pagedepth-pagemaxdepth;
pagedepth:=pagemaxdepth;
END;
IF(emptypage<>0) AND(mem[mem[25001].twohalves
.lhword].twohalves.byte2<>2)
AND(newht<pagetopbl) THEN
BEGIN
p:=getnode(2);
mem[p].twohalves.byte2:=4;
mem[p+1].twohalves.lhword:=interlineglue(pagetopbl-newht,16);
mem[pagetail].twohalves.lhword:=p;
pagetail:=p;
newht:=pagetopbl;
END;
pageheight:=pageheight+olddp+newht;
emptypage:=0;
END;
3:
pageext(mem[25001].twohalves.lhword);
4, 5:
IF emptypage<>0 THEN
BEGIN
q:=mem[25001].twohalves.lhword;
mem[25001].twohalves.lhword:=mem[q].twohalves.lhword;
IF mem[q].twohalves.byte2=4 THEN
BEGIN delgluelink(mem[q+1].twohalves
.lhword);
freenode(q,2)
END
ELSE BEGIN dsnodelist(mem[q+1].twohalves
.lhword);
freenode(q,2)
END;
action:=7;
moretopage:=0;
GOTO 50;
END
ELSE BEGIN
CASE c OF
0, 1, 12:
IF testpagebreak(0.0) THEN BEGIN
action:=8;
moretopage:=0;
GOTO 50;
END;
OTHERS:
END;
IF mem[mem[25001].twohalves.lhword].twohalves.byte2=4 THEN
BEGIN
q:=mem[mem[25001].twohalves.lhword+1].twohalves.lhword;
pageheight:=pageheight+pagedepth+mem[q+1].pts;
pagedepth:=0.0;
pagestretch:=pagestretch+mem[q+2].pts;
pageshrink:=pageshrink+mem[q+3].pts;
END;
END;
8:
IF emptypage<>0 THEN
BEGIN
q:=mem[25001].twohalves.lhword;
mem[25001].twohalves.lhword:=mem[q].twohalves.lhword;
freenode(q,2);
action:=7;
moretopage:=0;
GOTO 50;
END
ELSE BEGIN
d:=mem[mem[25001].twohalves.lhword+1].int;
IF(d<1000) AND(d<32767) THEN
IF testpagebreak(d/100.0) THEN
BEGIN action:=8;
moretopage:=0;
GOTO 50;
END;
END;
10: BEGIN
IF(emptypage<2) OR(finaleject
AND(pagetail<>25002)) THEN
BEGIN
IF curbreak=0 THEN curbreak:=pagetail;
breakpage:=testpagebreak(-2.0)
;
action:=8;
END
ELSE BEGIN
p:=mem[25001].twohalves.lhword;
mem[25001].twohalves.lhword:=mem[p].twohalves.lhword;
freeavail(p);
action:=7;
END;
moretopage:=0;
GOTO 50;
END;
12:
BEGIN curins:=mem[mem[25001].twohalves
.lhword+1].twohalves.lhword;
IF mem[curins].twohalves.byte2=2 THEN
BEGIN q:=mem[25001].twohalves
.lhword;
mem[25001].twohalves.lhword:=mem[q].twohalves.lhword;
mem[q].twohalves.lhword:=0;
dsnodelist(q);
action:=7;
moretopage:=0;
GOTO 50;
END;
q:=mem[curins].twohalves.byte3;
IF(mem[curins].twohalves.byte2=1) AND(emptypage<>2) THEN
BEGIN
newht:=pageheight+mem[curins+1].pts
+pageinsdepth[q];
newshr:=pageshrink+mem[curins+3].pts
;
IF insabsent[q] THEN BEGIN qq:=25*q;
IF mem[qq].twohalves.lhword<>0 THEN BEGIN
newshr:=newshr+mem[qq+3].pts;
newht:=newht+mem[qq+1].pts;
IF(q=0) OR(emptypage=0)
OR(NOT insabsent[0]) THEN
newht:=newht+mem[qq+4].pts;
END;
END;
IF(q=0) OR(NOT insabsent[0])
THEN
newht:=newht+pagedepth+pageinsdepth[1]
ELSE IF emptypage=0 THEN newht:=newht+pageinsdepth[1]
;
IF(newht-newshr>pagesize+0.0001)
THEN
BEGIN
mem[waitingtail].twohalves.lhword:=
mem[25001].twohalves.lhword;
waitingtail:=mem[25001].twohalves.lhword;
mem[25001].twohalves.lhword:=
mem[mem[25001].twohalves.lhword].twohalves.lhword;
mem[waitingtail].twohalves.lhword:=0;
action:=7;
moretopage:=0;
GOTO 50;
END;
END;
IF insabsent[q] THEN
BEGIN insabsent[q]:=false;
qq:=5*q;
IF mem[20+qq].twohalves.lhword<>0 THEN BEGIN
pq:=getnode(5);
mem[pq].twohalves.byte2:=2;
mem[pq].twohalves.byte3:=q;
mem[pq].twohalves.lhword:=boxcopy(mem[20+qq].twohalves
.lhword);
mem[pq+1]:=mem[(21)+qq];
mem[pq+2]:=mem[(22)+qq];
mem[pq+3]:=mem[(23)+qq];
mem[pq+4]:=mem[(24)+qq];
pp:=getnode(2);
mem[pp].twohalves.byte2:=12;
mem[pp+1].twohalves.lhword:=pq;
mem[pp].twohalves.lhword:=0;
pageheight:=pageheight+mem[pq+1].pts;
pagestretch:=pagestretch+mem[pq+2].pts;
pageshrink:=pageshrink+mem[pq+3].pts;
mem[pagetail].twohalves.lhword:=pp;
pagetail:=pp;
IF q=0 THEN
pageheight:=pageheight+mem[20+4].pts
ELSE
pageinsdepth[1]:=mem[25+4].pts;
END;
END;
pageheight:=pageheight+mem[curins+1].pts;
IF q=0 THEN BEGIN
pageheight:=pageheight+pageinsdepth[0];
pageinsdepth[0]:=mem[curins+4].pts;
END;
pagestretch:=pagestretch+mem[curins+2].pts;
pageshrink:=pageshrink+mem[curins+3].pts;
IF emptypage<>0 THEN emptypage:=1;
END;
11:;
OTHERS:
confusion
END;
mem[pagetail].twohalves.lhword:=
mem[25001].twohalves.lhword;
pagetail:=mem[25001].twohalves.lhword;
mem[25001].twohalves.lhword:=
mem[mem[25001].twohalves.lhword].twohalves.lhword;
mem[pagetail].twohalves.lhword:=0;
IF(mem[pagetail].twohalves.byte2=12) AND(mem[curins].twohalves
.byte2=1) THEN
IF testpagebreak(0.0) THEN BEGIN
action:=8;
moretopage:=0;
GOTO 50;
END;
action:=7;
moretopage:=0;
50:
END;
PROCEDURE pageeject;
LABEL 23;
VAR p,q,i: integer;
BEGIN
mem[pagetail].twohalves.lhword:=mem[25001].twohalves.lhword;
p:=mem[curbreak].twohalves.lhword;
mem[curbreak].twohalves.lhword:=0;
WHILE p<>0 DO
BEGIN
IF(p>25000) THEN GOTO 23;
CASE mem[p].twohalves.byte2
OF
4: delgluelink(mem[p+1].twohalves.lhword);
5: dsnodelist(mem[p].twohalves.lhword);
8:;
10: BEGIN q:=mem[p].twohalves.lhword;
freenode(p,2);
p:=q;
GOTO 23
END;
OTHERS:
GOTO 23
END;
q:=mem[p].twohalves.lhword;
freenode(p,2);
p:=q;
END;
23:
mem[25001].twohalves.lhword:=p;
IF mem[25000].twohalves.lhword<>0 THEN BEGIN
mem[waitingtail].twohalves.lhword:=mem[25001].twohalves.lhword;
mem[25001].twohalves.lhword:=mem[25000].twohalves.lhword;
mem[25000].twohalves.lhword:=0;
waitingtail:=25000
END;
IF topmark<>0 THEN delrclink(topmark);
topmark:=botmark;
IF botmark<>0 THEN mem[botmark].twohalves.rhword:=
mem[botmark].twohalves.rhword+1;
IF firstmark<>0 THEN delrclink(firstmark);
firstmark:=-1;
curbox:=vpackage(25002,pagesize,true,false);
IF firstmark<0 THEN
BEGIN firstmark:=botmark;
mem[botmark].twohalves.rhword:=mem[botmark].twohalves.rhword+1
END;
mem[25002].twohalves.lhword:=0;
pagetail:=25002;
emptypage:=2;
FOR i:=48 TO 57 DO savedknt[i]:=kount[i];
IF(eqtb[1408].int<>4194784)
THEN
IF odd(eqtb[1408].twohalves.lhword
DIV 2)
THEN BEGIN
println(290);
printint(savedknt[48]);
print(58);
tracedump(curbox);
END;
END;
FUNCTION endinsertion: integer;
VAR d: integer;
p,q: integer;
BEGIN
WITH savestack[saveptr].fourbytes
DO d:=rhword;
IF(d<=9) THEN BEGIN
p:=getnode(2);
mem[p].twohalves.byte2:=4;
IF d=9 THEN BEGIN
q:=eqtb[5].fourbytes.rhword;
mem[p+1].twohalves.lhword:=q;
mem[curnode].twohalves.lhword:=p
END
ELSE BEGIN
q:=eqtb[6].fourbytes.rhword;
mem[p+1].twohalves.lhword:=q;
mem[p].twohalves.lhword:=mem[head].twohalves.lhword;
mem[head].twohalves.lhword:=p
END;
mem[q].twohalves.rhword:=mem[q].twohalves.rhword+1;
q:=getnode(5);
mem[q].twohalves.byte2:=0;
END
ELSE BEGIN
q:=20+(d-10)*5;
IF mem[q].twohalves.lhword<>0 THEN
dsnodelist(mem[q].twohalves.lhword);
mem[q].twohalves.byte2:=2;
END;
p:=vpackage(head,0,false,true);
mem[q].twohalves.byte3:=(d-8) MOD 2;
mem[q].twohalves.lhword:=mem[p+1].twohalves.lhword;
mem[q+1].pts:=mem[p+4].pts;
mem[q+2].pts:=str;
mem[q+3].pts:=shr;
mem[q+4].pts:=mem[p+2].pts;
freenode(p,7);
endinsertion:=q;
END;
PROCEDURE mathscan;
LABEL 50;
VAR p, intnum: integer;
BEGIN
REPEAT getnctok UNTIL curcmd<>10;
p:=savestack[saveptr].int;
WITH mem[p].fourbytes DO
BEGIN
IF(curcmd=11) OR(curcmd=12) THEN
BEGIN byte0:=2;
byte2:=(eqtb[curchar+1265].fourbytes.byte2 MOD 8);
byte3:=eqtb[curchar+1265].fourbytes.byte3;
GOTO 50;
END;
IF curcmd=58 THEN
BEGIN byte0:=2;
byte2:=(curfont MOD 8);
byte3:=curchar;
GOTO 50;
END;
IF curcmd=27 THEN
BEGIN intnum:=scannumber;
byte0:=2;
byte3:=intnum MOD 128;
intnum:=intnum DIV 128;
byte2:=(intnum MOD 8);
GOTO 50;
END;
END;
IF curcmd<>1 THEN
BEGIN
alignstate:=alignstate+1;
println(184);
error;
END;
saveptr:=saveptr+1;
newsavelevel(16);
pushnest;
aux.int:=0;
50:
END;
PROCEDURE finishcommand;
LABEL 0, 1, 2;
VAR p,q: integer;
BEGIN
0:
CASE action OF
3: BEGIN
println(291);
showmode(mode);
print(292);
error;
END;
21: BEGIN
println(293);
error;
END;
4: BEGIN
pausingonerrors:=false;
println(294);
error;
quit;
END;
6: BEGIN
alignstate:=alignstate+1;
println(295);
error;
saveptr:=saveptr+1;
curlev:=curlev+1;
END;
5:
BEGIN
IF curcmd>15 THEN
BEGIN curtyp:=0;
curval:=hashentry
END
ELSE BEGIN curtyp:=curcmd;
curval:=curchar
END;
WITH savestack[saveptr].fourbytes
DO
IF(byte0=0) AND(rhword=5) THEN
BEGIN
backinput;
println(299);
error;
curcmd:=3
END
ELSE IF(byte0=0) AND(rhword=14) THEN
BEGIN
backinput;
println(300);
error;
curcmd:=61;
curchar:=13;
q:=getavail;
mem[q].twohalves.byte2:=12;
mem[q].twohalves.byte3:=46;
mem[q].twohalves.lhword:=0;
inslist(q)
END
ELSE BEGIN
backinput;
println(179);
error;
curcmd:=2
END;
saveptr:=saveptr+1;
curlev:=curlev+1;
GOTO 2;
END;
12: BEGIN
getncnext;
IF curcmd<>36 THEN
BEGIN
WITH savestack[saveptr].fourbytes
DO
IF(rhword>=58) AND(rhword<=60)
AND((curcmd=47) OR(curcmd=46))
THEN
BEGIN curbox:=scanrulespec;
action:=15;
GOTO 0;
END;
println(301);
error;
GOTO 2;
END;
action:=13;
GOTO 0;
END;
13: IF boxbegin=1 THEN GOTO 1
ELSE GOTO 0;
14: BEGIN boxjust;
popnest;
action:=15;
GOTO 0;
END;
15: IF boxfinish=1 THEN GOTO 1
ELSE GOTO 0;
17: BEGIN
IF abs(mode)=167 THEN BEGIN
p:=getnode(2);
mem[p].twohalves.byte2:=14;
WITH mem[p+1].fourbytes
DO BEGIN byte0:=3;
rhword:=curitem END;
BEGIN
mem[curnode].twohalves.lhword:=p;
curnode:=p;
END;
GOTO 1;
END;
BEGIN
mem[curnode].twohalves.lhword:=curitem;
curnode:=curitem;
END;
IF mode=1 THEN BEGIN action:=7;
GOTO 0;
END
ELSE GOTO 1;
END;
11: BEGIN REPEAT getnctok UNTIL
curcmd<>10;
IF curcmd=43 THEN
BEGIN scanlb;
newsavelevel(7);
GOTO 1;
END;
IF curcmd=2 THEN
BEGIN endalign;
IF mode=1 THEN BEGIN action:=7;
GOTO 0;
END;
IF mode=167 THEN
BEGIN
getnctok;
IF(curcmd<>3) OR(mem[head].twohalves
.lhword<>0) THEN
BEGIN
println(302);
error
END;
GOTO 2;
END;
GOTO 1;
END;
backinput;
startalignbox;
startunsetnode;
GOTO 1;
END;
19: BEGIN
curnoad:=getnode(4);
mem[curnoad].twohalves.byte2:=0;
WITH mem[curnoad+1].fourbytes
DO
BEGIN
IF curbox>0 THEN byte0:=1
ELSE IF curbox<0 THEN BEGIN byte0
:=3;
curbox:=-curbox END
ELSE byte0:=0;
rhword:=curbox;
END;
mem[curnoad+3].fourbytes.byte0:=0;
mem[curnoad+2].fourbytes.byte0:=0;
BEGIN
mem[curnode].twohalves.lhword:=curnoad;
curnode:=curnoad;
END;
GOTO 1;
END;
18:BEGIN
curnoad:=getnode(4);
WITH mem[curnoad].twohalves
DO BEGIN byte2:=curfont DIV 8;
byte3:=0 END;
curfont:=(curfont MOD 8);
WITH mem[curnoad+1].fourbytes DO
BEGIN byte0:=2;
byte2:=curfont;
byte3:=curchar
END;
mem[curnoad+3].fourbytes.byte0:=0;
mem[curnoad+2].fourbytes.byte0:=0;
BEGIN
mem[curnode].twohalves.lhword:=curnoad;
curnode:=curnoad;
END;
GOTO 1;
END;
20: BEGIN mathscan;
GOTO 1;
END;
16: BEGIN q:=endinsertion;
popnest;
IF mem[q].twohalves.byte2=2 THEN GOTO 1;
p:=getnode(2);
mem[p].twohalves.byte2:=12;
mem[p+1].twohalves.lhword:=q;
IF mode=1 THEN
BEGIN mem[25001].twohalves.lhword:=p;
mem[q].twohalves.byte2:=1;
action:=7;
GOTO 0;
END;
BEGIN
mem[curnode].twohalves.lhword:=p;
curnode:=p;
END;
GOTO 1;
END;
7: IF moretopage=1 THEN GOTO 1
ELSE GOTO 0;
8: BEGIN pageeject;
outputdormant:=false;
IF outputroutine<>0 THEN
BEGIN pushnest;
mode:=-1;
aux.pts:=-(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0);
newsavelevel(6);
insrclist(outputroutine);
savedpage:=curbox;
GOTO 1
END;
action:=10;
GOTO 0;
END;
9: BEGIN
IF mem[head].twohalves.lhword<>0 THEN
curbox:=vpackage(head,0,false,true)
ELSE curbox:=0;
popnest;
IF savedpage<>0 THEN
BEGIN
BEGIN
println(303);
error
END;
dsnodelist(savedpage);
savedpage:=0
END;
action:=10;
GOTO 0;
END;
10:
BEGIN
IF curbox<>0 THEN
BEGIN print(296);
printint(savedknt[48]);(* PRINTLN(297);
PRINTINT(VARUSED);
PRINT(44);
PRINTINT(DYNUSED);*);
shipout(curbox);
deadcycles:=0;
dsnodelist(curbox);(* PRINT(298);
PRINTINT(VARUSED);
PRINT(44);
PRINTINT(DYNUSED);*);
print(93);
forcebufferout;
END
ELSE deadcycles:=deadcycles+1;
outputdormant:=true;
action:=7;
GOTO 0;
END;
OTHERS:
confusion;
END;
1:
getnext;(* IF(CHECKINGMEM<>0) THEN
CHECKMEM(FALSE);*);
2:
END;
PROCEDURE initstacks;
BEGIN
nestptr:=0;
mode:=1;
mem[25002].twohalves.lhword:=0;
pagetail:=25002;
mem[25001].twohalves.lhword:=0;
curnode:=25001;
mem[25000].twohalves.lhword:=0;
waitingtail:=25000;
emptypage:=2;
finaleject:=false;
head:=25001;
aux.pts:=-(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0);
alignptr:=0;
alignlist:=0;
alignrecord:=0;
alignstate:=-1000;
outputdormant:=true;
hangbegin:=32767;
hangfirst:=0;
parshape:=0;
parptr:=0;
deadcycles:=0;
topmark:=0;
firstmark:=0;
botmark:=0;
dimmode:=0;(* CHECKINGMEM:=0;*)
END;
PROCEDURE terminategroup;
LABEL 1, 2;
BEGIN
inhangbegin:=eqtb[1405].int;
inhangfirst:=eqtb[1406].int;
inhangwidth:=eqtb[1407].pts;
CASE unsave OF
1: BEGIN
println(304);
error;
GOTO 1;
END;
2: GOTO 1;
3: BEGIN
REPEAT getnctok UNTIL curcmd<>10
;
IF curcmd<>35 THEN BEGIN
backinput;
println(327);
error;
END;
passblock;
GOTO 1;
END;
17: BEGIN
getnctok;
IF curcmd=10 THEN getnctok;
GOTO 2;
END;
5, 14:
BEGIN action:=6;
finishcommand;
GOTO 2;
END;
4: BEGIN
IF alignrecord<0 THEN
BEGIN action:=6;
finishcommand;
GOTO 2;
END;
curtyp:=2;
curval:=126;
backinput;
println(305);
error;
curlev:=curlev+1;
saveptr:=saveptr+1;
curcmd:=5;
aligndelim;
GOTO 1;
END;
6: BEGIN action:=9;
finishcommand;
GOTO 2;
END;
7: BEGIN action:=11;
finishcommand;
GOTO 2;
END;
9, 8, 11, 10: BEGIN
action:=16;
finishcommand;
GOTO 2;
END;
12: BEGIN
saveptr:=saveptr-3;
action:=14;
finishcommand;
GOTO 2;
END;
13: BEGIN
curbox:=-finishmlist(0);
action:=19;
finishcommand;
GOTO 2;
END;
16: BEGIN
curitem:=finishmlist(0);
saveptr:=saveptr-1;
WITH mem[savestack[saveptr].int
].fourbytes
DO
BEGIN byte0:=3;
rhword:=curitem
END;
GOTO 1;
END;
15: BEGIN
saveptr:=saveptr-1;
curnoad:=getnode(4);
mem[curnoad].twohalves.byte2:=0;
WITH savestack[saveptr].fourbytes
DO mem[curnoad].twohalves.byte3:=rhword;
WITH mem[curnoad+1].fourbytes
DO
BEGIN byte0:=1;
rhword:=vpackage(head,0,false,true)
END;
mem[curnoad+2].fourbytes.byte0:=0;
mem[curnoad+3].fourbytes.byte0:=0;
popnest;
BEGIN
mem[curnode].twohalves.lhword:=curnoad;
curnode:=curnoad;
END;
GOTO 1
END;
OTHERS:
confusion
END;
1:
getnext;
(* IF(CHECKINGMEM<>0) THEN
CHECKMEM(FALSE);*);
2:
END;
PROCEDURE startparagraph;
VAR q: integer;
BEGIN
q:=getnode(2);
mem[q].twohalves.byte2:=4;
mem[q+1].twohalves.lhword:=eqtb[3].fourbytes.rhword;
mem[eqtb[3].fourbytes.rhword].twohalves.rhword:=
mem[eqtb[3].fourbytes.rhword].twohalves.rhword+1;
mem[curnode].twohalves.lhword:=q;
curnode:=q;
pushnest;
mode:=84;
aux.pts:=1.0;
IF curcmd<>52 THEN
BEGIN
q:=getnode(7);
mem[q].twohalves.byte2:=0;
mem[q+1].twohalves.lhword:=0;
mem[q+3].pts:=pagemem[3];
mem[q+4].pts:=0.0;
mem[q+2].pts:=0.0;
mem[q+5].pts:=0.0;
mem[q+6].pts:=0.0;
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END
ELSE BEGIN
getnext;(* IF(CHECKINGMEM<>0)
THEN CHECKMEM(FALSE);*);
END;
END;
PROCEDURE adjustglue;
LABEL 2;
VAR curfnt: integer;
q: integer;
BEGIN
CASE curchar OF
11: BEGIN getnctok;
IF curcmd<>10 THEN GOTO 2;
END;
10: BEGIN
curfnt:=eqtb[0].fourbytes.rhword;
IF curfnt=255 THEN
BEGIN action:=4;
finishcommand;
GOTO 2;
END;
q:=getnode(2);
mem[q].twohalves.byte2:=4;
BEGIN
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END;
q:=getnode(4);
mem[q].twohalves.rhword:=0;
mem[q+1].pts:=fmem[parbase[curfnt]+5].pts
;
mem[q+2].pts:=0.0;
mem[q+3].pts:=0.0;
mem[curnode+1].twohalves.lhword:=q;
END;
OTHERS:
BEGIN
action:=3;
finishcommand;
GOTO 2;
END
END;
getnext;(* IF(CHECKINGMEM<>0)
THEN CHECKMEM(FALSE);*);
2:
END;
PROCEDURE initmathmode;
LABEL 2;
BEGIN
IF(eqtb[0+1393].int=255)
OR(eqtb[1+1393].int=255)
OR(eqtb[2+1393].int=255)
OR(eqtb[3+1393].int=255) THEN
BEGIN action:=4;
finishcommand;
GOTO 2;
END;
eqtb[7+1393].int:=eqtb[3+1393].int;
eqtb[11+1393].int:=eqtb[3+1393].int;
getnctok;
IF(mode<0) AND(curcmd=3) THEN
BEGIN action:=3;
finishcommand;
GOTO 2;
END;
newsavelevel(5);
IF curcmd<>3 THEN
BEGIN pushnest;
mode:=-167;
aux.int:=0;
GOTO 2;
END;
IF mem[head].twohalves.lhword=0 THEN
BEGIN
abovedspwidth:=-1000000.0;
popnest END
ELSE BEGIN
finishparagraph(false);
abovedspwidth:=lastwidth+(2.0*fmem[parbase[eqtb[2+1393].int
]+5].pts);
hangbegin:=hangbegin-lines;
q:=getnode(2);
BEGIN
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END;
mem[curnode].twohalves.byte2:=8;
mem[curnode+1].int:=eqtb[1417].int END;
pushnest;
mode:=167;
aux.int:=0;
eqnobox:=0;
dpenalty:=0;
action:=7;
finishcommand;
2:
END;
PROCEDURE processchar;
LABEL 22, 0, 2;
VAR finf: bytes4;
j: integer;
curfnt: integer;
lchar,llchar: integer;
itm: integer;
p,q: integer;
lkstep: bytes4;
BEGIN
curfnt:=eqtb[0].fourbytes.rhword;
IF curfnt=255 THEN
BEGIN action:=4;
finishcommand;
GOTO 2;
END;
lchar:=curchar;
22:
IF(sftable[curchar]<>0.0)
AND((NOT(curnode>25000)) OR
(mem[curnode].twohalves.byte3<65) OR
(mem[curnode].twohalves.byte3>90))
THEN aux.pts:=sftable[curchar];
finf:=fontinfo[curfnt,curchar];
itm:=getavail;
WITH mem[itm].twohalves
DO
BEGIN byte2:=curfnt;
byte3:=curchar END;
getnext;
IF(finf.byte2 MOD 4)=1 THEN
BEGIN
j:=finf.byte3+lgbase[curfnt];
WHILE true DO
BEGIN
lkstep:=fmem[j].fourbytes;
IF(lkstep.byte1=curchar)
AND((curcmd=11) OR(curcmd=12))
THEN BEGIN llchar:=lchar;
lchar:=curchar;
curchar:=lkstep.byte3;
IF(lkstep.byte2<128)
THEN BEGIN freeavail(itm);
GOTO 22;
END;
BEGIN
mem[curnode].twohalves.lhword:=itm;
curnode:=itm;
END;
IF llchar=45 THEN
BEGIN
q:=getnode(2);
mem[q].twohalves.byte2:=9;
mem[q].twohalves.byte3:=1;
BEGIN
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END;
END;
p:=getnode(2);
mem[p].twohalves.byte2:=6;
mem[p+1].pts:=fmem[curchar+krbase[curfnt]].pts;
BEGIN
mem[curnode].twohalves.lhword:=p;
curnode:=p;
END;
curchar:=lchar;
GOTO 2;
END;
IF(lkstep.byte0>=128)
THEN GOTO 0;
j:=j+1
END;
0:
END;
BEGIN
mem[curnode].twohalves.lhword:=itm;
curnode:=itm;
END;
IF lchar=45 THEN BEGIN
q:=getnode(2);
mem[q].twohalves.byte2:=9;
mem[q].twohalves.byte3:=1;
BEGIN
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END;
END;
2:
END;
PROCEDURE accentchar;
LABEL 2;
VAR s,t,w,h: real;
curfnt: integer;
p,q,r: integer;
c, fntnum: integer;
BEGIN
curfnt:=eqtb[0].fourbytes.rhword;
IF curfnt=255 THEN
BEGIN action:=4;
finishcommand;
GOTO 2;
END;
s:=fmem[parbase[curfnt]].pts;
t:=fmem[parbase[curfnt]+4].pts;
c:=curchar;
fntnum:=curfnt;
p:=getavail;
mem[p].twohalves.byte2:=curfnt;
mem[p].twohalves.byte3:=curchar;
getnctok;
WHILE curcmd=19 DO
BEGIN
curfnt:=scanfont(true);
eqdefine(0,19,curfnt);
getnctok;
END;
IF curcmd=27 THEN curchar:=scannumber
MOD 128
ELSE IF(curcmd<>11) AND(curcmd<>12)
AND(curcmd<>60) THEN
BEGIN
println(306);
error;
GOTO 2;
END;
q:=getavail;
mem[q].twohalves.byte2:=curfnt;
mem[q].twohalves.byte3:=curchar;
r:=getnode(2);
mem[r].twohalves.byte2:=4;
mem[r+1].twohalves.lhword:=12;
mem[r].twohalves.lhword:=q;
q:=getnode(7);
mem[q].twohalves.byte2:=0;
mem[q+1].twohalves.lhword:=p;
WITH fontinfo[fntnum,c] DO
BEGIN
mem[q+3].pts:=fmem[wdbase[fntnum]+byte0
].pts;
mem[q+4].pts:=fmem[htbase[fntnum]+(byte1
DIV 16)].pts;
mem[q+2].pts:=fmem[dpbase[fntnum]+(byte1
MOD 16)].pts;
END;
mem[q+6].pts:=0.0;
mem[q+5].pts:=0.0;
mem[q].twohalves.lhword:=r;
WITH fontinfo[curfnt,curchar]
DO
BEGIN
w:=fmem[wdbase[curfnt]+byte0].pts;
h:=fmem[htbase[curfnt]+(byte1
DIV 16)].pts;
END;
mem[q+5].pts:=(w-mem[q+3].pts
)/2+fmem[parbase[curfnt]].pts
*h-s*t;
p:=vpack(q,mem[q+4].pts+h-t,false);
mem[p+3].pts:=w;
BEGIN
mem[curnode].twohalves.lhword:=p;
curnode:=p;
END;
getnext;(* IF(CHECKINGMEM<>0) THEN
CHECKMEM(FALSE);*);
2:
END;
PROCEDURE setdelimiters;
LABEL 1, 2;
VAR p: integer;
delimiters: bytes4;
BEGIN
p:=curchar;
IF p=13 THEN
IF unsave<>14 THEN
BEGIN
WITH savestack[saveptr].fourbytes
DO
IF(byte0<>0) OR(rhword<>5) THEN
BEGIN action:=5;
finishcommand;
GOTO 2;
END;
scandelim(delimiters);
println(307);
error;
saveptr:=saveptr+1;
curlev:=curlev+1;
GOTO 1
END;
curnoad:=getnode(4);
mem[curnoad].twohalves.byte2:=p;
scandelim(delimiters);
mem[curnoad+1].fourbytes:=delimiters;
mem[curnoad+2].fourbytes.byte0:=0;
mem[curnoad+3].fourbytes.byte0:=0;
IF p=12 THEN
BEGIN newsavelevel(14);
pushnest;
aux.int:=0;
mem[head].twohalves.lhword:=curnoad;
curnode:=curnoad;
GOTO 1
END;
curbox:=-finishmlist(curnoad);
action:=19;
finishcommand;
GOTO 2;
1:
getnext;
2:
END;
PROCEDURE setcharcode;
VAR j: integer;
intnum: integer;
improper: boolean;
BEGIN
j:=curchar;
intnum:=scannumber;
IF(intnum<0) OR(intnum>255)
THEN improper:=true
ELSE improper:=false;
j:=1137+j+intnum;
getnctok;
IF curcmd=15 THEN BEGIN
backinput;
println(179);
error;
curcmd:=2
END;
intnum:=scannumber;
IF nbrsign=45 THEN intnum:=-intnum;
IF improper OR(j>=1429) OR((j<1265)
AND(intnum>14))
OR((j<=1392) AND(intnum>2047))
THEN BEGIN println(195);
error
END
ELSE BEGIN
IF(j>=1265) AND(j<=1392) THEN
WITH chrcode.fourbytes
DO
BEGIN byte2:=((intnum DIV 128) MOD 4)+(intnum
DIV 512)*8;
byte3:=intnum MOD 128;
END
ELSE IF j=1409 THEN chrcode.pts:=intnum
ELSE IF j=1419 THEN
WITH chrcode.fourbytes DO
BEGIN byte3:=intnum MOD 128;
intnum:=intnum DIV 128;
byte2:=intnum MOD 4;
intnum:=intnum DIV 4;
byte1:=intnum MOD 128;
intnum:=intnum DIV 128;
byte0:=intnum MOD 4;
END
ELSE IF j=1408 THEN
WITH chrcode.twohalves DO
BEGIN
lhword:=intnum DIV 32768;
intnum:=intnum MOD 32768;
rhword:=intnum DIV 64;
intnum:=intnum MOD 64;
rhword:=rhword*2+(intnum DIV 32);
intnum:=intnum MOD 32;
rhword:=rhword*2+(intnum MOD 2);
intnum:=intnum DIV 2;
lhword:=lhword*4+(intnum MOD 4);
intnum:=intnum DIV 4;
rhword:=rhword*2+(intnum DIV 2);
lhword:=lhword*2+(intnum MOD 2);
END
ELSE chrcode.int:=intnum;
chcodedef(j,chrcode)
END;
END;
PROCEDURE putabove;
LABEL 1;
VAR len:real;
delimiters: bytes4;
BEGIN
IF(aux.int<>0) AND(aux.pts<>
-(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0)) THEN
BEGIN
CASE curchar OF
0: len:=scanlength;
1, 2:;
3: BEGIN scandelim(delimiters);
scandelim(delimiters)
END;
OTHERS:
confusion
END;
println(308);
error;
GOTO 1;
END;
aux.int:=getnode(6);
mem[aux.int].twohalves.byte2:=11;
WITH mem[aux.int+2].fourbytes
DO IF mem[head].twohalves.lhword<>0 THEN
BEGIN byte0:=3;
rhword:=mem[head].twohalves.lhword
END
ELSE byte0:=0;
mem[aux.int+3].fourbytes.byte0:=0;
CASE curchar OF
0: BEGIN mem[aux.int+1].pts:=scanlength;
WITH mem[aux.int+4].fourbytes
DO BEGIN byte0:=0;
byte1:=0;
byte2:=0;
byte3:=0 END;
WITH mem[aux.int+5].fourbytes
DO BEGIN byte0:=0;
byte1:=0;
byte2:=0;
byte3:=0 END;
END;
1: BEGIN mem[aux.int+1].pts:=0.0;
WITH mem[aux.int+4].fourbytes
DO BEGIN byte0:=0;
byte1:=0;
byte2:=0;
byte3:=0 END;
WITH mem[aux.int+5].fourbytes
DO BEGIN byte0:=0;
byte1:=0;
byte2:=0;
byte3:=0 END;
END;
2: BEGIN mem[aux.int+1].pts:= fmem[parbase[eqtb[3+1393].int]+7].pts;
WITH mem[aux.int+4].fourbytes
DO BEGIN byte0:=0;
byte1:=0;
byte2:=0;
byte3:=0 END;
WITH mem[aux.int+5].fourbytes
DO BEGIN byte0:=0;
byte1:=0;
byte2:=0;
byte3:=0 END;
END;
3: BEGIN mem[aux.int+1].pts:=0.0;
scandelim(delimiters);
mem[aux.int+4].fourbytes:=delimiters;
scandelim(delimiters);
mem[aux.int+5].fourbytes:=delimiters;
END;
OTHERS:
confusion
END;
mem[head].twohalves.lhword:=0;
curnode:=head;
1:
END;
PROCEDURE endmath;
LABEL 1, 2;
VAR d: integer;
p,q: integer;
BEGIN
d:=mode;
IF unsave<>5 THEN
BEGIN action:=5;
finishcommand;
GOTO 2;
END;
p:=finishmlist(0);
IF d>0 THEN BEGIN
getnctok;
IF curcmd<>3 THEN BEGIN
backinput;
println(328);
error;
END;
p:=compactlist(evalmlist(p,0,false));
finishdisplay(p);
getnctok;
IF curcmd<>10 THEN backinput;
pushnest;
mode:=84;
aux.pts:=1.0;
action:=7;
finishcommand;
GOTO 2;
END;
p:=compactlist(evalmlist(p,1,true));
IF mode=167 THEN BEGIN
eqnobox:=hpack(p,0,true);
GOTO 2;
END;
IF pagemem[5]<>0 THEN
BEGIN
q:=getnode(2);
mem[q].twohalves.byte2:=6;
mem[q+1].pts:=pagemem[5];
BEGIN
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END;
END;
q:=getnode(2);
mem[q].twohalves.byte2:=7;
mem[q+1].int:=0;
mem[q].twohalves.lhword:=p;
BEGIN
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END;
WHILE mem[curnode].twohalves.lhword<>0 DO
curnode:=mem[curnode].twohalves.lhword;
q:=getnode(2);
mem[q].twohalves.byte2:=7;
mem[q+1].int:=1;
BEGIN
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END;
IF pagemem[5]<>0 THEN
BEGIN
q:=getnode(2);
mem[q].twohalves.byte2:=6;
mem[q+1].pts:=pagemem[5];
BEGIN
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END
END;
aux.pts:=1.0;
1:
getnext;(* IF(CHECKINGMEM<>0) THEN
CHECKMEM(FALSE);*);
2:
END;
PROCEDURE appendspace;
LABEL 1, 2;
VAR p,q: integer;
curfnt: integer;
BEGIN
p:=eqtb[10].fourbytes.rhword;
IF(p=16)OR((mem[p+1].pts=0) AND(mem[p+2].pts=0) AND(mem[p+3].pts=0))
THEN
BEGIN
curfnt:=eqtb[0].fourbytes.rhword;
IF curfnt=255 THEN
BEGIN action:=4;
finishcommand;
GOTO 2;
END;
p:=30+curfnt*4;
END;
IF(aux.pts<>1.0) AND(curcmd<>59) THEN
BEGIN
q:=getnode(4);
mem[q].twohalves.rhword:=0;
mem[q+1].pts:=mem[p+1].pts;
mem[q+2].pts:=mem[p+2].pts*aux.pts;
mem[q+3].pts:=mem[p+3].pts/aux.pts;
IF aux.pts>2.0 THEN
BEGIN p:=eqtb[12].fourbytes.rhword;
IF(p=16)
OR((mem[p+1].pts=0) AND(mem[p+2].pts
=0) AND(mem[p+3].pts=0))
THEN BEGIN curfnt:=eqtb[0].fourbytes.rhword;
IF curfnt=255 THEN
BEGIN action:=4;
finishcommand;
GOTO 2;
END;
mem[q+1].pts:=mem[q+1].pts+fmem[parbase[curfnt]+6].pts;
p:=q;
END
ELSE mem[p].twohalves.rhword:=mem[p].twohalves.rhword+1;
END
ELSE p:=q;
END
ELSE mem[p].twohalves.rhword:=mem[p].twohalves.rhword+1;
q:=getnode(2);
mem[q].twohalves.byte2:=4;
mem[q+1].twohalves.lhword:=p;
BEGIN
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END;
1:
getnext;(* IF(CHECKINGMEM<>0) THEN
CHECKMEM(FALSE);*);
2:
END;
PROCEDURE finishpage;
BEGIN
IF 25002=pagetail THEN
BEGIN
IF(deadcycles=0) OR(deadcycles>25)
THEN
BEGIN
IF curlev<>1 THEN BEGIN
println(309);
printint(curlev-1);
print(310)
END;
quit;
END;
pagetail:=getnode(7);
mem[pagetail].twohalves.byte2:=0;
mem[pagetail+1].twohalves.lhword:=0;
mem[pagetail+4].pts:=pagemem[1];
mem[pagetail+3].pts:=pagemem[0];
mem[pagetail+2].pts:=0.0;
mem[pagetail+6].pts:=0.0;
mem[pagetail+5].pts:=0.0;
mem[25002].twohalves.lhword:=pagetail;
END;
finaleject:=true;
curtyp:=0;
curval:=hashentry;
backinput;
curcmd:=53;
curchar:=1;
END;
PROCEDURE appendglue;
LABEL 2;
VAR p: integer;
BEGIN
IF curchar=100 THEN
BEGIN
IF abs(mode)<>167 THEN
BEGIN action:=3;
finishcommand;
GOTO 2;
END;
dimmode:=1;
curchar:=0;
p:=getnode(2);
mem[p].twohalves.byte2:=15;
mem[p].twohalves.byte3:=18;
BEGIN
mem[curnode].twohalves.lhword:=p;
curnode:=p;
END
END;
CASE curchar OF
0: p:=scanglue;
1: p:=0;
2: p:=4;
3: p:=8;
4: p:=12;
OTHERS:
confusion
END;
dimmode:=0;
curitem:=getnode(2);
mem[curitem].twohalves.byte2:=4;
mem[curitem+1].twohalves.lhword:=p;
action:=17;
finishcommand;
2:
END;
PROCEDURE appendusualglue;
LABEL 2;
VAR p: integer;
BEGIN
p:=eqtb[13+(scandigit-48)].fourbytes.rhword;
mem[p].twohalves.rhword:=mem[p].twohalves.rhword+1;
curitem:=getnode(2);
mem[curitem].twohalves.byte2:=4;
mem[curitem+1].twohalves.lhword:=p;
action:=17;
finishcommand;
2:
END;
PROCEDURE sethangindent;
VAR hw: real;
hb: integer;
hf: integer;
BEGIN
hw:=scanlength;
IF scanstring(311) THEN
BEGIN hb:=scannumber;
hf:=1 END
ELSE IF scanstring(312) THEN
BEGIN hb:=scannumber;
hf:=0 END
ELSE BEGIN
hb:=1;
hf:=0
END;
IF mode=-84 THEN
BEGIN
chrcode.int:=hb;
chcodedef(1405,chrcode);
chrcode.int:=hf;
chcodedef(1406,chrcode);
chrcode.pts:=hw;
chcodedef(1407,chrcode);
END
ELSE
BEGIN hangbegin:=hb;
hangfirst:=hf;
hangwidth:=hw
END;
END;
PROCEDURE ungluebox;
LABEL 1, 2;
VAR d: integer;
p: integer;
t: integer;
BEGIN
d:=scandigit;
p:=savedbox[d];
IF p<>0 THEN
BEGIN
CASE mem[p].twohalves.byte2
OF
0: t:=84;
1: t:=1;
OTHERS:
confusion
END;
IF abs(mode)<>t THEN
BEGIN
println(313);
error;
GOTO 1;
END;
p:=mem[p+1].twohalves.lhword;
freenode(savedbox[d],7);
END;
savedbox[d]:=0;
mem[curnode].twohalves.lhword:=p;
WHILE p<>0 DO
BEGIN curnode:=p;
p:=mem[p].twohalves.lhword
END;
IF abs(mode)=1 THEN aux.pts:=
-(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0)
ELSE aux.pts:=1.0;
IF mode=1 THEN BEGIN action:=7;
finishcommand;
GOTO 2;
END;
1:
getnext;
(* IF(CHECKINGMEM<>0) THEN
CHECKMEM(FALSE);*);
2:
END;
PROCEDURE sendonstream;
VAR c: integer;
d: integer;
p: integer;
BEGIN
c:=curchar;
d:=scandigit;
IF c=0 THEN BEGIN
curcmd:=50;
hashentry:=hashsend;
p:=getnode(2);
mem[p].twohalves.byte2:=3;
mem[p].twohalves.byte3:=0;
mem[p].twohalves.lhword:=0;
mem[p+1].twohalves.rhword:=d;
mem[p+1].twohalves.lhword:=scantoks;
gettok;
IF curcmd<>10 THEN backinput;
whatsitappend(p);
action:=7;
finishcommand;
END
ELSE BEGIN getnctok;
IF curcmd=15 THEN
BEGIN backinput;
println(314);
error
END;
opendigit(d);
getnext;(* IF(CHECKINGMEM<>0)
THEN CHECKMEM(FALSE);*);
END;
END;
PROCEDURE testdimension;
LABEL 50;
VAR s: real;
BEGIN
s:=scanlength;
WHILE true DO
BEGIN
getnctok;
CASE curchar OF
60: BEGIN scancond(s<scanlength);
GOTO 50 END;
61: BEGIN scancond(s=scanlength);
GOTO 50 END;
62: BEGIN scancond(s>scanlength);
GOTO 50 END;
29: BEGIN scancond(s>=scanlength);
GOTO 50 END;
27: BEGIN scancond(s<>scanlength);
GOTO 50 END;
28: BEGIN scancond(s<=scanlength);
GOTO 50 END;
OTHERS:
BEGIN
backinput;
println(315);
error;
END
END
END;
50:
END;
PROCEDURE defalternate;
LABEL 24, 1;
VAR c: integer;
p: integer;
lhsplace,rhsplace: integer;
BEGIN
gettok;
lhsplace:=hashentry;
IF lhsplace<0 THEN GOTO 24;
getnctok;
gettok;
rhsplace:=hashentry;
IF rhsplace<0 THEN GOTO 24;
WITH eqtb[rhsplace].fourbytes DO
BEGIN c:=byte0; p:=rhword END;
IF c=16 THEN mem[p].twohalves.rhword:=mem[p].twohalves.rhword+1;
eqdefine(lhsplace,c,p);
GOTO 1;
24:
backinput;
println(316);
error;
1:
END;
PROCEDURE changecase;
VAR c: integer;
p,q: integer;
BEGIN
c:=curchar;
p:=scantoks;
q:=mem[p].twohalves.lhword;
WHILE q<>0 DO
BEGIN
IF mem[q].twohalves.byte2=11 THEN
BEGIN
IF c<>0 THEN
BEGIN
IF(mem[q].twohalves.byte3>=97) AND (mem[q].twohalves.byte3<=122) THEN
mem[q].twohalves.byte3:=mem[q].twohalves.byte3-(97-65)
END
ELSE
BEGIN
IF(mem[q].twohalves.byte3>=65) AND (mem[q].twohalves.byte3<=90) THEN
mem[q].twohalves.byte3:=mem[q].twohalves.byte3+(97-65)
END;
END;
q:=mem[q].twohalves.lhword;
END;
pushinput;
WITH curinput DO
BEGIN
state:=0;
recovery.rhword:=3;
recovery.lhword:=p;
loc:=mem[p].twohalves.lhword;
END;
END;
PROCEDURE setsupsubscript;
VAR p: integer;
BEGIN
IF(curnode=head) OR(mem[curnode].twohalves
.byte2>=11)
OR(mem[curnode+curcmd-5].fourbytes
.byte0<>0) THEN
BEGIN
p:=getnode(4);
mem[p].twohalves.byte2:=0;
mem[p].twohalves.byte3:=0;
mem[p+1].fourbytes.byte0:=0;
mem[p+2].fourbytes.byte0:=0;
mem[p+3].fourbytes.byte0:=0;
mem[curnode].twohalves.lhword:=p;
IF(curnode<>head) AND(mem[curnode].twohalves.byte2<11) THEN
BEGIN
println(317);
IF curcmd=7 THEN print(318)
ELSE print(319);
print(320);
error
END;
curnode:=p END;
savestack[saveptr].int:=curnode+curcmd-5;
action:=20;
finishcommand;
END;
PROCEDURE testtrue;
LABEL 2;
VAR c: integer;
BEGIN
getnctok;
IF curcmd>=14 THEN
BEGIN
BEGIN
backinput;
println(321);
error;
END;
GOTO 2;
END
ELSE c:=curchar;
getnctok;
IF curcmd>=14 THEN
BEGIN
backinput;
println(321);
error;
END
ELSE scancond(curchar=c);
2:
END;
PROCEDURE testequivalent;
VAR p1,p2: integer;
cmd1,char1: integer;
BEGIN
gettok;
WHILE hashentry<0 DO
BEGIN
backinput;
println(322);
error;
gettok;
END;
IF curcmd=16 THEN
p1:=mem[mem[mem[curchar].twohalves.lhword].twohalves.lhword].twohalves.lhword
ELSE
BEGIN
p1:=-1;
cmd1:=curcmd;
char1:=curchar;
END;
gettok;
WHILE hashentry<0 DO
BEGIN
backinput;
println(322);
error;
gettok;
END;
IF curcmd=16 THEN p2:=mem[mem[mem[curchar].twohalves
.lhword].twohalves.lhword].twohalves.lhword
ELSE p2:=-1;
IF(p1<0) OR(p2<0) THEN
BEGIN
IF(cmd1<>curcmd) OR((curcmd<>0)AND(char1<>curchar)) THEN p2:=0;
END
ELSE WHILE(p1>0) AND(p2>0) AND
(mem[p1].twohalves.rhword=mem[p2].twohalves.rhword) DO
BEGIN p1:=mem[p1].twohalves.lhword;
p2:=mem[p2].twohalves.lhword;
END;
scancond(p1=p2);
END;
PROCEDURE savelist;
BEGIN
IF curcmd=55 THEN
BEGIN curnoad:=getnode(5);
mem[curnoad].twohalves.byte2:=10;
WITH mem[curnoad+4].fourbytes DO
BEGIN byte2:=curfont; byte3:=curchar END
END
ELSE BEGIN curnoad:=getnode(4);
mem[curnoad].twohalves.byte2:=curchar END;
mem[curnoad+1].fourbytes.byte0:=0;
mem[curnoad+2].fourbytes.byte0:=0;
mem[curnoad+3].fourbytes.byte0:=0;
BEGIN
mem[curnode].twohalves.lhword:=curnoad;
curnode:=curnoad;
END;
savestack[saveptr].int:=curnoad+1;
action:=20;
finishcommand;
END;
PROCEDURE applyitcorr;
VAR cicindex: integer;
p: integer;
BEGIN
IF(curnode=head) OR(NOT(curnode>25000)) THEN
BEGIN
println(323);
error
END
ELSE WITH mem[curnode].twohalves DO
BEGIN
cicindex:=fontinfo[byte2,byte3].byte2 DIV 4;
IF cicindex<>0 THEN
BEGIN
p:=getnode(7);
mem[p].twohalves.byte2:=0;
mem[p+1].twohalves.lhword:=0;
mem[p+3].pts:=fmem[icbase[byte2]+cicindex].pts;
mem[p+4].pts:=0.0;
mem[p+2].pts:=0.0;
mem[p+6].pts:=(0.000001*0.000001*0.00000001);
mem[p+5].pts:=0.0;
BEGIN
mem[curnode].twohalves.lhword:=p;
curnode:=p;
END;
END;
END;
aux.pts:=1.0;
END;
PROCEDURE alignit;
LABEL 2;
BEGIN
IF unsave<>4 THEN
BEGIN action:=5;
finishcommand;
GOTO 2;
END;
finishunsetnode;
newsavelevel(4);
IF alignrecord<0 THEN
BEGIN
finishalignbox;
action:=11;
finishcommand;
GOTO 2;
END;
alignrecord:=mem[alignrecord].twohalves.lhword;
startunsetnode;
getnext;
(* IF(CHECKINGMEM<>0)
THEN CHECKMEM(FALSE);*);
2:
END;
PROCEDURE allocateeqno;
BEGIN
pushnest;
mode:=-167;
aux.int:=0;
newsavelevel(5);
IF curchar=0 THEN leqno:=false
ELSE leqno:=true;
END;
PROCEDURE dotrace;
BEGIN
IF(eqtb[1408].int<>4194784)
THEN
BEGIN
IF odd(eqtb[1408].twohalves.lhword DIV 4)
THEN dumpactivities;
IF odd(eqtb[1408].twohalves.rhword DIV 4)
THEN
BEGIN println(324);
error;
END
END
ELSE BEGIN dumpactivities;
println(325);
error
END;
END;
PROCEDURE setfont;
VAR c: integer;
BEGIN
c:=curchar;
chrcode.int:=scanfont(true);
chcodedef(1393+c,chrcode);
IF c<>3 THEN BEGIN
chrcode.int:=scanfont(true);
chcodedef(1393+c+4,chrcode);
chrcode.int:=scanfont(true);
chcodedef(1393+c+8,chrcode);
END;
END;
PROCEDURE inccounter;
VAR d,j: integer;
BEGIN
d:=scandigit;
IF scanstring(326) THEN j:=scannumber
ELSE BEGIN
j:=1;
IF kount[d]<0 THEN nbrsign:=45
ELSE nbrsign:=43;
END;
IF nbrsign=43 THEN kount[d]:=kount[d]+j
ELSE kount[d]:=kount[d]-j;
END;
PROCEDURE displacebox;
VAR c: integer;
BEGIN
c:=curchar;
len:=scanlength;
IF nbrsign=45 THEN len:=-len;
IF c<>0 THEN len:=-len;
savestack[saveptr].pts:=len;
action:=12;
finishcommand;
END;
PROCEDURE appendrule;
LABEL 1, 2;
VAR p: integer;
BEGIN
p:=scanrulespec;
BEGIN
mem[curnode].twohalves.lhword:=p;
curnode:=p;
END;
IF abs(mode)=1 THEN
BEGIN
aux.pts:=-(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0);
IF mode>0 THEN BEGIN action:=7;
finishcommand;
GOTO 2;
END
ELSE GOTO 1;
END;
aux.pts:=1.0;
1:
getnext;(* IF(CHECKINGMEM<>0)
THEN CHECKMEM(FALSE);*);
2:
END;
PROCEDURE insertmark;
LABEL 2;
VAR p: integer;
BEGIN
IF outputdormant THEN
BEGIN action:=21;
finishcommand;
GOTO 2;
END;
CASE curchar OF
0: p:=botmark;
1: p:=topmark;
2: p:=firstmark
END;
IF p<>0 THEN insrclist(p);
getnext;(* IF(CHECKINGMEM<>0)
THEN CHECKMEM(FALSE);*);
2:
END;
PROCEDURE appendmarknode;
VAR p,q: integer;
BEGIN
p:=scantoks;
q:=getnode(2);
mem[q].twohalves.byte2:=11;
mem[q+1].twohalves.lhword:=p;
BEGIN
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END;
IF mode=1 THEN
BEGIN action:=7;
finishcommand;
END
ELSE BEGIN
getnctok;
IF curcmd<>10 THEN backinput;
getnext;(* IF(CHECKINGMEM<>0)
THEN CHECKMEM(FALSE);*);
END
END;
PROCEDURE appendpennode;
LABEL 2;
VAR j,p: integer;
BEGIN
p:=curchar;
IF(p<>0) AND(mode<>167) THEN
action:=3
ELSE BEGIN
j:=scannumber;
IF j>32767 THEN j:=32767;
IF nbrsign=45 THEN j:=-j;
IF p<>0 THEN
BEGIN dpenalty:=j;
getnext;(* IF(CHECKINGMEM<>0)
THEN CHECKMEM(FALSE);*);
GOTO 2;
END;
curitem:=getnode(2);
mem[curitem].twohalves.byte2:=8;
mem[curitem+1].int:=j;
action:=17;
END;
finishcommand;
2:
END;
PROCEDURE appendejectnode;
BEGIN
IF(mode=+167) OR((curchar=0)AND(abs(mode)=1)) THEN action:=3
ELSE
BEGIN
curitem:=getnode(2);
WITH mem[curitem].twohalves DO
BEGIN byte2:=10; byte3:=curchar END;
action:=17;
END;
finishcommand;
END;
PROCEDURE appenddiscnode;
LABEL 2;
VAR curfnt: integer;
q: integer;
BEGIN
curfnt:=eqtb[0].fourbytes.rhword;
IF curfnt=255 THEN
BEGIN action:=4;
finishcommand;
GOTO 2;
END;
q:=getnode(2);
mem[q].twohalves.byte2:=9;
mem[q].twohalves.byte3:=2;
WITH mem[q+1].twohalves
DO
BEGIN byte2:=curfnt;
byte3:=curchar
END;
BEGIN
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END;
getnext;(* IF(CHECKINGMEM<>0)
THEN CHECKMEM(FALSE);*);
2:
END;
PROCEDURE precenter;
BEGIN
WITH savestack[saveptr].fourbytes
DO rhword:=curchar;
saveptr:=saveptr+1;
newsavelevel(15);
pushnest;
mode:=-1;
aux.pts:=-(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0);
scanlb;
END;
PROCEDURE delglue;
VAR p,q: integer;
BEGIN
IF(NOT(curnode>25000)) AND
(mem[curnode].twohalves.byte2=4) THEN
BEGIN p:=head;
q:=mem[p].twohalves.lhword;
WHILE q<>curnode DO BEGIN p:=q;
q:=mem[p].twohalves.lhword;
END;
delgluelink(mem[curnode+1].twohalves
.lhword);
freenode(curnode,2);
mem[p].twohalves.lhword:=0;
curnode:=p;
END;
END;
PROCEDURE getshape;
VAR intnum,j: integer;
BEGIN
IF parshape<>0 THEN freenode(parshape,2*mem[parshape].int+1);
intnum:=scannumber;
IF intnum<>0 THEN
BEGIN parshape:=getnode(2*intnum+1);
mem[parshape].int:=intnum;
FOR j:=1 TO intnum DO
BEGIN
mem[parshape+2*j-1].pts:=scanlength;
mem[parshape+2*j].pts:=scanlength;
END;
END
ELSE parshape:=0;
END;
PROCEDURE maincontrol;
LABEL 1, 2, 50;
VAR c: integer;
d,j: integer;
oldchar:integer;
intnum: integer;
p,q: integer;
BEGIN
initstacks;
1:
getnext;
(* IF(CHECKINGMEM<>0) THEN CHECKMEM(FALSE);*)
2:
CASE abs(mode)+curcmd OF
1, 84, 167:
BEGIN
BEGIN
println(180);
error
END;
GOTO 1
END;
2, 85:
BEGIN
newsavelevel(2);
GOTO 1
END;
168:
BEGIN
newsavelevel(13);
pushnest;
aux.int:=0;
GOTO 1
END;
3, 86, 169:
BEGIN terminategroup;
GOTO 2;
END;
4, 12, 13, 53, 56,
61, 63, 60:
BEGIN
IF mode<0 THEN BEGIN action:=3;
finishcommand;
GOTO 2 END;
startparagraph;
GOTO 2;
END;
87: BEGIN
initmathmode;
GOTO 2;
END;
224: BEGIN
IF mode<0 THEN BEGIN action:=3;
finishcommand;
GOTO 2 END;
allocateeqno;
GOTO 1
END;
170:
BEGIN endmath;
GOTO 2;
END;
5, 6, 88, 89, 171, 172:
BEGIN
println(329);
error;;
GOTO 1
END;
174, 175:
BEGIN setsupsubscript;
GOTO 2;
END;
11, 14, 177: GOTO 1;
94, 143:
BEGIN appendspace;
GOTO 2;
END;
150: BEGIN adjustglue;
GOTO 2;
END;
226, 233:
BEGIN
q:=getnode(2);
mem[q].twohalves.byte2:=15;
mem[q].twohalves.byte3:=curchar;
BEGIN
mem[curnode].twohalves.lhword:=q;
curnode:=q;
END;
GOTO 1
END;
178, 179:
BEGIN
WITH eqtb[curchar+1265].fourbytes
DO
BEGIN curfont:=byte2;
curchar:=byte3
END;
action:=18;
finishcommand;
GOTO 2;
END;
225: BEGIN action:=18;
finishcommand;
GOTO 2;
END;
194: BEGIN
intnum:=scannumber;
curchar:=intnum MOD 128;
intnum:=intnum DIV 128;
curfont:=(intnum MOD 8);
action:=18;
finishcommand;
GOTO 2;
END;
95, 96, 144:
BEGIN processchar;
GOTO 2;
END;
97: BEGIN
IF mode<0 THEN GOTO 1;
IF mem[head].twohalves.lhword<>0 THEN finishparagraph(true)
ELSE popnest;
hangbegin:=32767;
hangfirst:=0;
action:=7;
finishcommand;
GOTO 2;
END;
180, 182:
BEGIN
curtyp:=curcmd;
BEGIN
backinput;
println(299);
error;
curcmd:=3
END;
GOTO 2
END;
16, 99:
BEGIN alignit;
GOTO 2
END;
17, 100, 183:
BEGIN
macrocall;
GOTO 1
END;
18, 101, 184:
BEGIN
extop;
GOTO 1
END;
21, 104, 187:
BEGIN oldchar:=curchar;
pagemem[oldchar]:=scanlength;
GOTO 1
END;
80, 163, 246:
BEGIN
d:=curchar;
IF d=13 THEN d:=13+(scandigit-48);
p:=scanglue;
eqdefine(d,18,p);
GOTO 1
END;
20, 103:
BEGIN eqdefine(0,19,scanfont(true));
GOTO 1
END;
22, 105, 188:
BEGIN
macrodef(curchar);
GOTO 1
END;
23, 106, 189:
BEGIN
IF outputroutine<>0 THEN delrclink(outputroutine);
outputroutine:=scantoks;
GOTO 1
END;
24:
BEGIN
inputfile;
GOTO 1
END;
26:
BEGIN
IF mode<0 THEN BEGIN action:=3;
finishcommand;
GOTO 2 END;
finishpage;
GOTO 2;
END;
27, 110, 193:
BEGIN
dotrace;
GOTO 1
END;
28, 111:
BEGIN
curchar:=scannumber MOD 128;
curcmd:=12;
GOTO 2;
END;
29, 112, 195:
BEGIN setcharcode;
GOTO 1
END;
30, 113:
BEGIN setfont;
GOTO 1
END;
31, 114, 197:
BEGIN
d:=scandigit;
kount[d]:=scannumber;
IF nbrsign=45 THEN kount[d]:=-kount[d];
GOTO 1
END;
32, 115, 198:
BEGIN inccounter;
GOTO 1
END;
33, 116, 199:
BEGIN
insnum(kount[scandigit]);
GOTO 1
END;
34, 117, 200:
BEGIN
c:=curchar;
d:=scandigit;
IF c<>0 THEN scancond(kount[d]>0)
ELSE scancond(odd(kount[d]+1));
GOTO 1
END;
72, 155, 238:
BEGIN scancond(abs(mode)=curchar);
GOTO 1
END;
35, 118, 201:
BEGIN testtrue;
GOTO 1
END;
83, 166, 249:
BEGIN
testequivalent;
GOTO 1
END;
37, 120, 203:
BEGIN
savestack[saveptr].pts:=0.0;
action:=13;
finishcommand;
GOTO 2;
END;
74, 157:
BEGIN ungluebox;
GOTO 2;
END;
38, 122, 205:
BEGIN displacebox;
GOTO 2;
END;
40, 123, 206:
BEGIN
WITH savestack[saveptr].fourbytes
DO rhword:=scandigit;
action:=12;
finishcommand;
GOTO 2;
END;
41, 124:
BEGIN
WITH savestack[saveptr].fourbytes
DO rhword:=curchar;
action:=12;
finishcommand;
GOTO 2;
END;
42, 126, 208:
BEGIN
IF mode=-167 THEN
BEGIN action:=3;
finishcommand;
GOTO 2;
END;
initalign;
action:=11;
finishcommand;
GOTO 2;
END;
45, 129, 212:
BEGIN appendglue;
GOTO 2;
END;
81, 164, 247:
BEGIN appendusualglue;
GOTO 2;
END;
48, 130:
BEGIN
appendrule;
GOTO 2;
END;
49, 132:
BEGIN
IF mode<0 THEN BEGIN action:=3;
finishcommand;
GOTO 2 END;
IF(curchar>1) AND(mode<>1) THEN
BEGIN action:=3;
finishcommand;
GOTO 2;
END;
j:=curchar;
pushnest;
mode:=-1;
aux.pts:=-(1000000.0*1000000.0*1000000.0*1000000.0*1000000.0);
scanlb;
newsavelevel(8+j);
GOTO 1
END;
50, 133, 216:
BEGIN
insertmark;
GOTO 2;
END;
51, 134:
BEGIN
IF mode<0 THEN BEGIN action:=3;
finishcommand;
GOTO 2 END;
appendmarknode;
GOTO 2;
END;
52, 135, 218:
BEGIN appendpennode;
GOTO 2;
END;
54, 137, 220:
BEGIN appendejectnode;
GOTO 2;
END;
138:
BEGIN appenddiscnode;
GOTO 2;
END;
221:
BEGIN
curitem:=getnode(2);
mem[curitem].twohalves.byte2:=9;
mem[curitem].twohalves.byte3:=2;
WITH mem[curitem+1].twohalves
DO
BEGIN byte2:=curfont;
byte3:=curchar
END;
action:=17;
finishcommand;
GOTO 2;
END;
57, 140, 223:
BEGIN intnum:=scannumber;
IF abs(mode)=167 THEN curfont:=intnum
DIV 128;
curchar:=intnum MOD 128;
curcmd:=55;
GOTO 2
END;
139:
BEGIN accentchar;
GOTO 2;
END;
222, 230:
BEGIN savelist;
GOTO 2;
END;
228:
BEGIN setdelimiters;
GOTO 2;
END;
232:
BEGIN putabove;
GOTO 1;
END;
231:
BEGIN
IF(curnode>25000) OR(mem[curnode].twohalves
.byte2<>1) THEN
BEGIN
println(330);
error
END
ELSE mem[curnode].twohalves.byte3:=1-mem[curnode].twohalves.byte3;
GOTO 1
END;
146:
BEGIN changecase;
GOTO 1
END;
151:
BEGIN applyitcorr;
GOTO 1
END;
235:
BEGIN precenter;
GOTO 1
END;
70, 153:
BEGIN sethangindent;
GOTO 1;
END;
71, 154:
IF mode=1 THEN
BEGIN action:=3;
finishcommand;
GOTO 2;
END
ELSE
BEGIN
delglue;
GOTO 1
END;
75, 158, 241:
BEGIN sendonstream;
GOTO 2;
END;
76, 159, 242: BEGIN testdimension;
GOTO 1;
END;
73, 156, 239:
BEGIN c:=scanfont(false);
GOTO 1
END;
78, 161, 244:
BEGIN defalternate;
GOTO 1;
END;
79, 162, 245:
BEGIN getshape;
GOTO 1
END;
165:
BEGIN
aux.pts:=scanreal;
IF aux.pts<1.0 THEN aux.pts:=1.0;
GOTO 1
END;
OTHERS:
BEGIN action:=3;
finishcommand;
GOTO 2
END
END;
50:
END;
PROCEDURE inittables;
VAR sizestable: sizesarray;
k,j: integer;
BEGIN
initstrings;
IF NOT gettablesizes(sizestable)
OR(sizestable[0]<>25012) OR(sizestable[1]<>49152)
OR(sizestable[2]<>1009) OR(sizestable[3]<>89)
OR(sizestable[4]<>1429) OR(sizestable[5]<>373)
OR(sizestable[6]<>116) OR(sizestable[7]<>109)
OR(sizestable[8]<>30) OR(sizestable[9]<>8)
OR(sizestable[10]<>6400) OR(sizestable[11]<>23)
THEN
BEGIN
initsysdep(fourbytesize);
println(331);
println(332);
GOTO 101
END;
initsecondmem(mem);
initeqtb(eqtb,hash,hhead,hashpar,hashsend);
inithyphentb(readoutvariable,exceptable,
excephyph,suffix,prefix,btable);
initpagetb(pagemem);
initdelimtb(delimtable);
initfmem(fmem,wdbase,htbase,dpbase,icbase,lgbase,krbase,
extbase,parbase,fontinfo,fcksum,fpfb,fmag,fpfi,fmemptr);;
initsftable(3.0,3.0,3.0,2.0,1.5,1.25);
END;
BEGIN;
initmem;
inittables;
initializing:=65;
writeln(tty,'HIT <CALL> KEY, THEN TYPE REENTER<CR>'); break(tty);
WHILE initializing=65 DO BEGIN END;
(*EXTRA INSTRUCTIONS ARE NEEDED TO ALLOW FOR VARIATIONS IN CALL POINT*)
pausingonerrors:=true;
pausingonerrors:=true;
pausingonerrors:=true;
pausingonerrors:=true;
pausingonerrors:=true;
pausingonerrors:=true;
errcnt:=0;
deletsallowed:=true;
notnonstop:=true;
initsysdep(fourbytesize);
initext;
initsave;
initin;
initout;
maincontrol;
100:
IF nooutputyet THEN println(333)
ELSE closeout(dvibytecnt,lastpageptr,eqtb[1420].int
,maxpageheight,maxpagewidth,
parbase,fcksum,fmag,fontused);
finishext;;
101:
END.